New LAMPP Model Aims to Guide LLM Use in Programming Education

Large language models have upended the way programming is taught and learned, and a new perspective paper argues that the field still lacks a theory-based framework for responding. Writing in Frontiers in Artificial Intelligence, Rex Bringula and Fredrik Heintz propose the LLM-Assisted Modern Programming Pedagogy, or LAMPP, model, a theory-informed framework intended to guide the systematic integration of LLMs into programming education. The paper is a perspective, meaning it puts forward a proposed model and testable hypotheses rather than reporting experimental results, and the authors are explicit that the model’s effectiveness remains to be evaluated.

The starting point for the model is a tension the authors describe as a double-edged technology. LLMs can serve as learning assistants that help students understand concepts, generate code, debug programs, test outputs, and optimize code. At the same time, students can now produce correct or near-correct code instantly, without going through the traditional learning process, which makes programming less challenging and raises the risk that algorithmic thinking remains underdeveloped. When students submit code that is partially or fully LLM-generated, teachers struggle to determine what those students actually understand, threatening the validity and reliability of traditional assessment methods such as take-home machine problems. LLMs can also generate correct responses to text-based tests, which is often considered cheating.

Before LLMs, the authors note, programming education relied on a well-established repertoire. Students coded independently or collaborated with peers, drawing on lectures, textbooks, videos, and programmers’ blogs, and they debugged manually with feedback from teachers, classmates, or professional programmers. Teaching was typically teacher-led and labor-intensive, with instructors manually preparing slides, coding examples, assignments, and exams, often adapting resources from previous courses. Prior studies documented pedagogical approaches such as pair programming and peer support, cognitive apprenticeship, problem-based learning, and robot-based teaching, as well as active-learning strategies like the flipped classroom, project-based learning, and peer instruction. Assessment traditionally distinguished conceptual knowledge, measured through tests, rubrics, or interviews, from procedural knowledge, measured through live coding tests, machine problems, and debugging tasks.

The LAMPP model organizes its response around four design principles that map onto the core components of pedagogy: teaching, lesson design, engagement, and assessment. Ethics is added as a cross-cutting dimension because, in the authors’ analysis, ethical concerns cut across all aspects of pedagogy. The theoretical grounding comes from four learning theories: constructivism, social constructivism, self-regulated learning, and cognitive apprenticeship. Constructivism underpins the model’s insistence that students remain active builders of knowledge, formulating solutions, testing ideas, interpreting outputs, and reflecting on their understanding rather than passively accepting generated code. Social constructivism frames learning as occurring through interaction among students, teachers, and LLMs, with students questioning, evaluating, refining prompts, and incorporating or rejecting AI suggestions based on their own understanding.

Self-regulated learning theory addresses the engagement, assessment, and ethics dimensions by positioning students as proactive learners who set goals, monitor progress, evaluate their understanding, and adjust their strategies. In the LAMPP framing, students must actively regulate their LLM use, deciding when to seek assistance, evaluating the responses they receive, and reflecting on how the interaction contributes to their learning. Cognitive apprenticeship theory supports treating the LLM as a learning assistant akin to an expert or mentor that provides solutions, scaffolding, and feedback, taking on roles such as coding assistant, explainer, debugger, coach, or feedback provider. Crucially, the model conceptualizes the LLM not as a code generator but as an educational tool whose role is deliberately designed around learning objectives set by the teacher.

The first design principle calls for transforming instructional practices for LLM-facilitated learning. The model does not eliminate teacher-centered scaffolding; instead, it augments it through structured interactions with LLMs. Teachers are encouraged to design lessons that use LLMs as tools for exploration, comparison, feedback, and refinement rather than as direct providers of solutions. A worked example illustrates the approach: students receive a partially working program to debug and may ask an LLM for hints or explanations of errors rather than complete solutions, then formulate their own solutions, revise the code, run it, test different inputs, and refine the program. The teacher uses the LLM to scaffold reflection and deeper analysis while students remain responsible for the final solution.

The second design principle focuses on developing the competencies needed to program effectively with LLMs. Beyond established skills such as problem solving, coding, debugging, testing, and optimization, the authors argue students need additional capabilities: critical thinking, metacognitive skills, prompt formulation, communication, output evaluation, and reflection. The core mechanism is an iterative cycle of planning, prompting, evaluation, refinement, and reflection, in which students formulate intended solutions, communicate with AI tools, critically evaluate outputs, revise their work, and reflect on the process. The authors propose this as an empirically testable hypothesis: students who engage in such structured activities may demonstrate higher LLM-supported programming competencies than those who primarily use LLMs to generate code or who do not use them at all.

Assessment redesign is the third design principle, and arguably the most urgent given that LLMs can generate, complete, and improve programming solutions, making traditional assessment and AI-detection methods less reliable. The model proposes shifting from evaluating final outputs toward process-oriented skills, with classes progressing from AI-assisted learning to guided practice and ultimately to independent performance. Assessments may require students to explain AI-generated code, justify programming decisions, debug existing solutions, document their AI interactions, and complete related tasks without AI assistance. Traditional formats such as pencil-and-paper tests and practical coding tasks remain applicable but should be conducted within controlled classroom settings. The paper also proposes theory-anchored methods, including think-aloud protocols, code walkthroughs, debugging explanations, reflective reports, viva voce examinations, analytic rubrics, observation checklists, and process artifacts such as version histories and prompt logs.

The fourth design principle embeds ethical and responsible LLM use across all components, proposing two complementary mechanisms: shared norms and self-regulated LLM use. Grounded in social constructivism, academic integrity is treated as something negotiated within the learning community rather than a fixed set of rules, with students, instructors, and institutions jointly formulating policies and discussing acceptable and unacceptable LLM use. From the self-regulated learning perspective, LLM use is acceptable when students plan when feedback is appropriate, monitor how much of the solution they produce versus the LLM, and evaluate whether the solution is correct and whether they truly understand the code. The authors hypothesize that shared norms and self-regulated LLM use are positively associated with students’ responsible AI behavior, and they recommend that future studies identify which shared norms are actually agreed upon in programming classrooms.

The authors are candid about limitations. Constructivist and social constructivist strategies may substantially increase teachers’ workload, and documentation-heavy mechanisms under self-regulated learning and cognitive apprenticeship may shift students’ focus from programming learning to compliance with documentation. Practical constraints include class size, multiple class loads, absence of teaching assistants, missing institutional AI policies, limited teacher training, and unequal access to paid AI tools. To address unequal access, the authors suggest institutions provide approved AI tools and that teachers design tiered activities: no AI use, limited assistance for specific functions such as explanation or debugging, and extensive assistance, with tasks built around free-version features, for example by capping the number of prompts. The model’s proposed mechanisms, the authors conclude, should be tested empirically to determine whether they mitigate potential learning losses associated with inappropriate or excessive reliance on LLMs, and its design principles can be implemented incrementally across different instructional contexts, resources, and institutional conditions.

Subject of Research: A proposed theory-based model, LAMPP, for integrating large language models into programming education across teaching, lesson design, engagement, assessment, and ethics.

Article Title: Large language model-assisted modern programming pedagogy model: a perspective on teaching programming in the era of LLMs

Article References: Bringula, R., & Heintz, F. (2026). Large language model-assisted modern programming pedagogy model: a perspective on teaching programming in the era of LLMs. Frontiers in Artificial Intelligence, 9, Article 1945247. https://doi.org/10.3389/frai.2026.1945247

Image Credits: AI Generated

DOI: 10.3389/frai.2026.1945247

Keywords: large language models, programming education, LAMPP model, pedagogy, assessment, constructivism, self-regulated learning, cognitive apprenticeship, academic integrity, educational theory, AI ethics, computer science education