Should students type along when we live code? A critical look at a new study on note-taking

Live coding, writing and running code in front of the class while thinking aloud, is one of my favourite ways to teach programming. Students like it too. But every instructor who does it faces the same question: what should students be doing while we code? Typing along? Watching? Taking notes? And if they take notes, how do they capture code without falling behind?

A paper presented at ICER 2025 by Daniel Manesh, Tong Wu, Yan Chen and Sang Won Lee (Virginia Tech), “Understanding and Improving Student Note-Taking in Live Coding Lectures”, tackles exactly this question. It is a careful piece of work, and its results are worth discussing, including what they do not show.

What the study did

The authors first interviewed ten instructors who use live coding. There was no consensus on typing along: some saw it as an active way to follow and remember, others as a distraction that makes students fall behind and chase their own typos. Instructors also stressed that much of a lecture is not in the code (explanations, slides, drawings) and that they value students exploring and tinkering with the code.

From these insights they built a note-taking tool. The instructor’s code is streamed live to each student in a read-only tab; students take notes in a rich-text editor and can insert a snapshot of the instructor’s code with one click; a separate “playground” lets them run and modify any snippet. They then ran a within-subjects lab study with 57 students, who followed two 15-minute lectures (on Python generators and decorators), one with the new tool and one with a plain code editor where they typed along.

Screenshot of the note-taking tool: on the left, the instructor's live code in a read-only tab with a playground tab and a console; on the right, a rich-text notes editor containing timestamped snapshots of the instructor's code.
The note-taking tool tested in the study: (a) live copy of the instructor’s code, (b) playground, (c) console, (d) notes editor, (e) code snapshots added with (f) “Add to Notes”. Figure 1 from Manesh et al. (2025), CC BY 4.0.

What they found

  • Lower workload. With the new tool, NASA-TLX scores were lower on every dimension, with the largest differences in time pressure, effort and frustration. 91% of participants felt they kept up with the lecture, against 39% with the code editor.
  • Better notes. Notes captured almost twice as many of the ideas spoken in the lecture (12.6 vs 6.9 “idea units”), more code was labelled with an explanation, and copying errors almost disappeared.
  • No learning gain. Quiz scores were the same in both conditions, both right after the lecture and one week later.

My reading

The paper convincingly shows that students prefer not having to transcribe code and that they produce richer notes when they don’t. The step from there to learning is where I would be cautious, in both directions.

The null result on learning is not strong evidence of no effect. The sample was sized to detect differences in general, not small learning effects; the quizzes were short (six or seven items) and scores sat around 7.5 out of 10 in both conditions, leaving little room to separate them. The two topics also differed in difficulty, which adds noise to a within-subjects comparison of only two lectures.

Fifteen scripted minutes are not a lecture. The authors themselves suggest that the extra load of typing may simply not have been enough to overwhelm working memory in such a short session. In a real 90-minute class, with questions, digressions and a faster pace, the balance could look very different.

Three changes were tested at once. One-click copying, a rich-text editor and a clear visual separation between code and prose all came together. We cannot tell which of them produced the better notes. The “idea units” measure also naturally favours an interface built for writing prose over a code editor where explanations must be squeezed into comments.

Self-reports deserve some caution. Each participant saw both interfaces, the new one was obviously the novel one, and the lecturer was also its designer. Part of the preference may be novelty and enthusiasm rather than a lasting benefit.

The value of notes was only half tested. Notes help in two ways: writing them (encoding) and studying them later (storage). Students were allowed to use their notes during the take-home quiz, but they were never given time to review them, which is where better notes should pay off most.

Removing friction is not always neutral. The instructors interviewed believed that typing helps memory and that the errors students make while copying are learning opportunities. The authors suggest moving that practice to dedicated in-class exercises, which is sensible but untested. When copying becomes effortless, there is a risk of students becoming spectators who feel they understand because their notes look complete. With generative AI, copying code is already frictionless for our students; as I argued in a previous post, the real question is no longer how they get the code, but whether they can explain what it does and check that it is right. Seen this way, a tool that frees students from transcribing so they can write down why the code works is a step in the right direction, provided they actually do it.

The research this study opens up

  1. A semester in a real classroom. Deploy the tool in a course, link usage logs (snapshots taken, playground runs, notes revisited before exams) to exam results, and give students a real reason to study their notes.
  2. Take the intervention apart. A factorial design (copying vs typing, rich text vs code editor) would show which ingredient matters, and whether the visual separation alone nudges students to write more explanations.
  3. Longer, faster lectures and different learners. Vary lecture length and pace to see when typing along starts to hurt, and look at who benefits most: novices versus experienced students, students with lower working memory, non-native speakers, and students with disabilities for whom typing at speed is hardest.
  4. From capturing to explaining. Prompt students to add a short “what does this do and why” to each snapshot, a form of self-explanation, and compare it with notes or summaries generated by an AI assistant. Do AI-written notes help, or do they hollow out the encoding benefit of note-taking?
  5. Capture the process, not only the product. Instructors complained that the final code hides how it was built. Snapshots could become a timeline of the code’s evolution, with differences between versions, so students can replay the reasoning rather than just the result.
  6. Make note-taking social. In our own work on programming classes, students regulated their learning not only individually but also with peers (Goswami et al., CSCW 2023). Shared class notes, where students see each other’s snapshots, comments and open questions, could support exactly this kind of co-regulation.
  7. Beyond the lecture. The same “snapshot and explain” pattern could help students review code produced by an AI assistant, turning a passive copy-paste into an act of verification.

The tool is open source, which makes it easy to build on. My main take-away for teaching is modest but practical: giving students the instructor’s code instead of asking them to retype it makes live coding less stressful and their notes better, and it does not seem to cost anything in learning. Whether it can actually improve learning is the question the next studies need to answer.

Paper (open access): Manesh, D., Wu, T., Chen, Y., & Lee, S. W. (2025). Understanding and improving student note-taking in live coding lectures. In Proceedings of the 2025 ACM Conference on International Computing Education Research V.1 (ICER 2025). ACM. https://doi.org/10.1145/3702652.3744224

Best Paper Award at ACM CHI 2026 for our study on virtual workout buddies

Three smartphone screens from the study app: a combined human-robot exercising peer, a human-looking AI peer, and the step-count progression view.

I am proud to share that our paper When Workout Buddies Are Virtual: AI Agents and Human Peers in a Longitudinal Physical Activity Study received a Best Paper Award at the ACM CHI Conference on Human Factors in Computing Systems (CHI 2026), held in Barcelona on 13–17 April 2026. CHI is the leading international venue for human-computer interaction research, and Best Paper Awards go to the top 1% of accepted papers.

The paper is led by Alessandro Silacci, an alumnus of my Persuasive Technology Lab at HEC Lausanne, together with Arianna Boldi and Maurizio Caon (HES-SO University of Applied Sciences and Arts Western Switzerland, Fribourg), Amon Rapp (University of Turin) and myself. It is the lab’s second Best Paper Award at CHI, after our 2023 paper on research ethics and transparency.

What we did. Many people find it hard to stay physically active, and exercising with someone else helps. But can an AI agent play the role of a workout buddy? We ran a six-month randomised controlled trial with 280 participants. They exercised either alone, with a human peer, or with a simulated exercising peer driven by a large language model.

What we found. We call it a partnership paradox. Human peers created a stronger sense of social presence and motivated people through real comparison and accountability. AI peers gave steadier encouragement and a more reliable working alliance: consistent, low-stakes support. Our conclusion is that AI agents should not try to imitate human authenticity. Instead, they should add reliability to it. Hybrid designs that combine human presence with AI consistency may be the best way to help people stay active over time.

Congratulations to Alessandro and to all co-authors! The lab’s announcement is here.

Read the paper: Silacci, A., Cherubini, M., Boldi, A., Rapp, A., & Caon, M. (2026). When workout buddies are virtual: AI agents and human peers in a longitudinal physical activity study. In Proceedings of the 2026 CHI Conference on Human Factors in Computing Systems. ACM. https://doi.org/10.1145/3772318.3790303 · Preprint: arXiv:2602.01918

From syntax to specification: teaching computing when code writes itself

The September 2026 issue of Communications of the ACM carries an opinion piece by Ibrahim Albluwi and fifteen colleagues, “Computing Education When Writing Code Is No Longer the Challenge”. It is the outcome of a Dagstuhl seminar on generative AI in programming education, and it asks a simple question: what should we teach when producing code is no longer the hard part?

The authors’ answer is that the difficulty has moved. Before generating any code, students must be able to express what they want with enough precision (specification and design). After the code is produced, they must be able to read it, judge its quality and validate that it is correct and trustworthy. Banning the tools is not an option: students entering their first programming course in a few years will have always used them.

Diagram: before AI, humans analyze, design, implement, verify and validate; after AI, humans analyze, prompt, orchestrate, verify and validate while generative AI generates the code.
Shift in competencies before and after GenAI: the bottleneck moves from producing code to prompting, orchestrating and validating. Figure from Albluwi et al. (2026), Communications of the ACM, 69(9), licensed under CC BY 4.0.

The article proposes three levels of ambition, which the authors call Quickfix, Renovation and Visionary. They range from an explicit GenAI policy in every course and secured exams, to redesigned introductory courses and AI tutors, up to rebuilding the curriculum around design, requirements specification and testing. They also note that agentic AI systems only strengthen the case: the bottleneck is human judgement in framing problems, orchestrating work and evaluating results.

My take

I agree, and I would go further: we need to reimagine the curriculum from the ground up. LLMs are another abstraction layer, exactly like the move a few decades ago from assembly to interpreted programming languages. Each step let programmers say more about what they want and less about how the machine should do it.

The difference this time is the medium. LLMs let us express specifications in natural language, and natural language is polysemic: the same sentence can mean different things to different readers, and to different models. Ambiguities that a compiler would reject now quietly become code that does something we did not intend.

Education therefore has to shift from teaching the syntax of a specific language to teaching how to write specifications that avoid bugs and lead to efficient and effective code, and how to check that the result actually meets them. In short, we need to teach specification and verification.

Full article (open access): Albluwi, I., et al. (2026). Computing education when writing code is no longer the challenge. Communications of the ACM, 69(9), 22–25. https://doi.org/10.1145/3808702

Encouraging OSN users to respect other people’s privacy

With the increasing use of Social Media and Online Social Networks such as Facebook or Instagram) the question of conflicting privacy settings becomes more and more relevant.

Minkus et al. [1] conducted a study to focus on OSN behavior of parents and found that many privacy breaches may occur to children at the hands of others, namely, their parents and relatives. These authors also designed interventions to mitigate compulsive sharing on social networks. Screenshot 2020-04-05 14.00.01.png

[1] Tehila Minkus, Kelvin Liu, and Keith W. Ross. 2015. Children Seen But Not Heard: When Parents Compromise Children’s Online Privacy. In Proceedings of the 24th International Conference on World Wide Web (WWW ’15). International World Wide Web Conferences Steering Committee, Republic and Canton of Geneva, CHE, 776–786. DOI: https://doi.org/10.1145/2736277.2741124

Old good habits

This COVID-19 situation is pushing us to rethink what really matters, how we live and the way we consume resources. My grandmother used to tell me stories of her times. Coming from an agricoltural society, most families back then used to grow their own food. They also used to make bread at home. It is interesting to notice how the current situation nudged families to bake bread and pizza at home: a flashback of 70 years! There is something special about cooking your own food. There is something nice about baking bread: the smell, the taste, and … the wait!

I guess, what I am trying to say is that our society moves too fast. In the rush of consuming we do not appreciate what we have. We do not appreciate the little moments, the little things.

IMG_5228

Change your habits with … electric shocks!

While doing my literature review for a recent project on Multiparty Privacy Conflicts, I bumped on a startup that designed a bracelet that gives little electric shocks every time the user performs a self-defined bad habit (e.g., eating at a fast foot).

I guess, this type of approach might have some positive outcomes for the kind of habits that are automatic (e.g., touching your nose) but I am not sure that it might work to setup behaviors that involve more high-cognitive functions (e.g., learning a new language).

PAVLOK-106-copy-1.jpg

great names are like knots

great names are like knots—they’re woven from the same stringy material as other words, but in their particular arrangement, they catch, become junctions to which new threads arrive, from which other threads depart

Jack Cheng, writer , June 2012


Great article by Jack Cheng on the Slow Web Movement. I particularly liked these quotes:

– And where the Fast Web is built around real-timedness, the Slow Web is built around timeliness.

– But timeliness alone doesn’t make something Slow Web. …Reliable rhythms lead to predictable outcomes, and rhythm is an expression of moderation.

– Fast Web is destination-based. Slow Web is interaction-based

– Behavior change, not growth. Behavior change is about improving the lives of others, scale is about ego. Getting scale after nailing behavior change is easier than nailing behavior change (and thus having a shot at durability) after hitting scale.

– Fast Web is about information. Slow Web is about knowledge.

– Timely not real-time. Rhythm not random. Moderation not excess. Knowledge not information.