Teaching Programming With AI Is Now an Evidence-Based Decision
Most conversations about generative AI in programming courses still run on instinct. One camp wants to ban the tools to protect the fundamentals. The other wants to adopt them quickly so students are ready for an industry that has already changed. Both positions get argued from conviction, and both skip the step that should come first: looking at what the research says.
That step is now possible. In the past two years, computing education researchers have produced enough studies to move the question from opinion to evidence. The findings do not hand a clean win to either camp. They support bringing AI into the programming classroom, and they show that doing it badly can widen the gap between students who are already succeeding and those who are struggling. The case for integration and the case for careful design turn out to be the same case.
What the tools are good at
Start with the capability question, because for the types of problems we usually assign, it is no longer in serious dispute. Current large language models solve the kinds of problems we assign in introductory courses. A review of the field by Paul Denny and colleagues documents how code-generation tools went from a curiosity to a standard part of the programming workflow in a matter of months, and how readily they handle the small, well-specified problems that fill most CS1 assignments. The exam evidence is concrete. When James Finnie-Ansley and colleagues ran OpenAI’s Codex through two CS1 tests in 2022, its answers ranked seventeenth in a class of seventy-one, inside the top quartile, and that was an early model. Newer ones have only widened the margin.
The industry signal points the same direction. In April 2025, Microsoft’s CEO said as much as 30% of the company’s code was being written by AI. That figure is a remark on a conference stage, not a measured result, and “written by AI” has no agreed definition, so it deserves caution. As a marker of where professional practice is heading, though, it is hard to ignore. If we want graduates who can work the way their future colleagues already work, ignoring the tools is its own kind of risk.
The second strength is tutoring. A first-year case study by Liam Stienstra and colleagues used a ChatGPT-based tutor to teach a new topic, then tested students without assistance. The tool supported learning, and most students preferred the AI tutor to a human one. Their reasons are worth considering: it was always available, and it did not make them feel judged for asking a basic question. Purpose-built tutors push this further. Tools like CodeHelp, from Mark Liffiton and colleagues, and CodeAid, from Majeed Kazemitabaar and colleagues, wrap the model in guardrails so it nudges a student toward an answer instead of handing one over. Work by Harsh Kumar and colleagues, run across a classroom study and a larger controlled experiment, found that the structure an instructor puts around the tool changes how students use it. Guidance that prompted students to attempt a problem before turning to the model, or to reflect on their own thinking, cut down on aimless queries and on the habit of pasting an assignment straight into the chatbot verbatim without attempting it first.
There is also early evidence that the help does not vanish the moment the tool is taken away. In a controlled study, Kazemitabaar and colleagues gave sixty-nine beginners, ages ten to seventeen, a sequence of forty-five Python tasks. Half had an AI code generator during the authoring work. That group completed more tasks and scored higher on the authoring work. The natural worry is that they would fall apart once the tool was gone. They did not. On the modification tasks they had to do by hand, they performed no worse than the students who never had access. On a retention test a week later they came out slightly ahead, though the difference was not statistically significant. Encouraging and modest at once, which is the honest way to hold it.
So far this is the authentic optimistic story. It is also incomplete.
The catch is an equity problem
Learning with AI is not automatic, and the students it fails are the ones we should worry about most.
The clearest evidence comes from James Prather and colleagues, in a study with the apt title “The Widening Gap.” Using eye-tracking and think-aloud methods with novice programmers, they found that every metacognitive difficulty students had before AI is still present, and that new ones have appeared. The pattern that is concerning: students with higher grades and stronger self-efficacy used the tools to accelerate, while weaker students were often slowed down and left with what the authors call an illusion of competence. The work finished but the understanding did not. The same tool that helps a confident student move faster can help a struggling student fail without noticing.
Part of the reason can be found in a paper by Lev Tankelevitch and colleagues on the metacognitive demands of generative AI. Working with these systems asks the user to do things that are cognitively hard: state a goal precisely, break it into parts, judge whether the output is any good, and adjust course when it is not. The authors compare it to a manager delegating to a team. That is a demanding skill, and it is not one novices arrive with. Studies of how beginners actually use these tools back this up. A close look by James Prather and colleagues at novices working with Copilot found students leaving out details that matter, like input and output types, and, when a prompt failed, changing a few words in the prompt rather than supplying the missing requirements.
This is where the equity lens is needed. A tool that rewards students who already plan well, monitor their own understanding, and know what they do not know will tend to reward the students who were going to do fine anyway. Left unaddressed AI creates a larger equity gap.
What evidence-based design looks like
The same body of research points to what helps, and the through-line is consistent: slow students down enough to make them think, and build the supports that strong students supply for themselves.
Majeed Kazemitabaar and colleagues tested this directly. They compared a baseline that simply showed students AI-generated code with an explanation against seven techniques that required some engagement with the code before or after it appeared. The technique that worked best, called Lead-and-Reveal, brought what students thought they had learned closest to what they actually learned, without adding cognitive load. The effects were modest and the samples small, which the authors are candid about, but the direction matches everything else in the literature. Passive acceptance of generated code produces the illusion of learning. Forcing a small act of reasoning interrupts it.
Other design moves follow from the same logic. Scaffold the tool rather than handing it over, as Kumar’s guidance strategies did. Teach prompting as an explicit skill, since novices do not pick it up on their own. Move assessment toward process and away from the take-home artifact that a model can now generate in seconds. And give upper-level students structured practice with the messier task they will actually face at work: a study by Anshul Shah, Leo Porter, and colleagues taught students to use GitHub Copilot inside a large codebase and found a pattern they call one-shot prompting, where students ask the tool to build an entire feature at once and then spend their effort debugging what comes back. That is a teachable habit, and naming it is the first step to correcting it.
There is a quieter finding that reframes the whole debate. A 2025 replication study by Rita Garcia and Michelle Craig revisited a 2004 survey of what CS1 instructors teach and find hard to teach. Twenty years on, the basic concepts are largely unchanged, recursion is still the hardest thing to teach, and the newest challenge instructors name is teaching students to think and plan before they code. That difficulty predates generative AI. The shift toward planning, decomposition, and self-monitoring, the very skills AI makes more important, was already underway. The course it was happening in was already struggling: introductory programming has carried high failure rates for decades, documented by Jens Bennedsen and Michael Caspersen and revisited by Christopher Watson and Frederick Li, and the long line of work on Soloway’s rainfall problem, surveyed by Kathi Fisler, showed that many students finish CS1 unable to write a basic loop correctly. AI did not break the introductory course. It exposed problems the course already had.
You do not have to figure this out alone
The research is scattered across conferences and journals, which makes it hard for any individual instructor to assemble. That gap is part of what the Consortium for Generative AI in CS Education https://www.teachcswithai.org/about exists to close. Housed at UC San Diego’s Center for Research on Education, Assessment, and Teaching Excellence and led by Leo Porter, Daniel Zingaro, and Beth Simon, the consortium gathers course materials, research summaries, and a community of educators working through the same questions. Its partner network runs from professional bodies like ACM and SIGCSE to organizations focused on access and inclusion, which matters given what the research shows about who gets left behind. The point of the consortium is not to sell a position. It is to make the evidence usable, so that a faculty member redesigning a course in the summer is not starting from a blank page. About half of the articles I used for this article can be found in the consortium’s resources section.
Two of the consortium leads, Porter and Zingaro, have also written the classroom-ready version. Their book, Learn AI-Assisted Python Programming, reorders the introductory course around the skills the research elevates. They argue that the skills to write good software are evolving: problem decomposition, writing a specification, reading code, and testing matter more than they used to, while memorizing syntax and library details matters less. Two of the chapters teach students to read code, on the logic that if the assistant writes the code, the student’s job is to judge whether the assistant has done what the student intended. A full chapter covers testing and prompt engineering. Top-down design, the practice of breaking a large problem into smaller ones, runs across several chapters rather than appearing once. Debugging gets its own deep dive, a skill that think-aloud studies by Jacqueline Whalley and colleagues show novices tend to approach unsystematically. Porter and Zingaro grant that a future professional engineer should eventually learn to write code from scratch, but they argue it no longer makes sense as the starting place for most learners. That is a concrete answer to the camp that wants to ban the tools to protect the fundamentals: they are just sequenced differently and weighted toward the skills that matter most now, like reading code, testing, and breaking problems down, rather than writing syntax from memory. The book is available to the IU community through IUCAT on the Bloomington and Indianapolis campuses, in digital ebook (https://iucat.iu.edu/catalog/20590350) and streaming audio (https://iucat.iu.edu/catalog/21587005) formats.
What about large courses?
Class size does not change the goals, but it splits these design moves into two groups. Some work just as well with three hundred students as with thirty and cost the instructor no extra effort. Requiring an attempt before a student reaches for the tutor is a policy built into the assignment or the tool, not labor spent per student. Kumar’s guidance strategies were tested as exactly this kind of scalable intervention. The cognitive-engagement step is the same: Kazemitabaar’s Lead-and-Reveal shipped as a reusable task builder, so the prediction step runs for every student without the instructor touching it. The AI tutor itself has its strongest case here. Kumar frames LLM tutors as a response to growing class sizes where teacher presence is thin, CodeHelp was built for scalable support in large classes, and Stienstra’s students valued the tutor because it was always available, which a human teaching assistant in a 400-person course cannot be.
The moves that resist scale are both forms of assessment. Reading hundreds of process artifacts or grading prompts by hand does not work past a certain size. The realistic versions are to make the process artifact auto-gradeable or peer-reviewable, push it into teaching-assistant-led lab sections, assess prompts by outcome rather than by reading each one, and reserve the labor-heavy formats like oral checks for a rotating sample. The teaching of these skills scales fine, since a lecture is a lecture. The grading is what has to be redesigned.
Underneath this is the equity point. In a small class you can see who is drifting. In a large one, the student coasting on an illusion of competence is invisible, and that is the student Prather’s widening-gap study identifies as most at risk. The large-course adaptation is a triage logic: let the tools that scale support the median student, and aim scarce human attention, teaching-assistant hours, oral checks, early-alert outreach, at the students the tools are most likely to fail. Spreading human help evenly is the thing a big course cannot afford and the thing struggling students most need.
The opportunity
The strongest argument for bringing AI into programming education is not that the tools are impressive, though they are. It is that they force a reckoning with weaknesses the field has tolerated for decades: introductory courses where many students do not learn what we think they learn, and a persistent distance between what we teach and what graduates need. We can treat that reckoning as a threat to manage or as a chance to fix the course. The evidence says the fix is within reach, and that it depends less on the tools than on how we design around them.
A few things to consider trying next term:
Replace one take-home assignment with an in-class task that assesses process, not just the finished program.
Before students use an AI tutor, require them to attempt the problem and write down what they think the answer should be.
Teach one short lesson on writing a specification for a model, including input and output types, and grade a prompt the way you would grade code.
Pick a single cognitive-engagement move, such as having students predict what generated code will do before running it, and use it consistently for a unit.
References
Denny, P., Prather, J., Becker, B. A., Finnie-Ansley, J., Hellas, A., Leinonen, J., Luxton-Reilly, A., Reeves, B. N., Santos, E. A., & Sarsa, S. (2024). Computing Education in the Era of Generative AI. Communications of the ACM. https://doi.org/10.1145/3624720
Finnie-Ansley, J., Denny, P., Becker, B. A., Luxton-Reilly, A., & Prather, J. (2022). The Robots Are Coming: Exploring the Implications of OpenAI Codex on Introductory Programming. Australasian Computing Education Conference (ACE ’22). https://doi.org/10.1145/3511861.3511863
Kazemitabaar, M., Chow, J., Ma, C. K. T., Ericson, B. J., Weintrop, D., & Grossman, T. (2023). Studying the Effect of AI Code Generators on Supporting Novice Learners in Introductory Programming. CHI ’23. https://doi.org/10.1145/3544548.3580919
Prather, J., Reeves, B. N., Denny, P., Becker, B. A., Leinonen, J., Luxton-Reilly, A., Powell, G., Finnie-Ansley, J., & Santos, E. A. (2023). “It’s Weird That it Knows What I Want”: Usability and Interactions with Copilot for Novice Programmers. ACM Transactions on Computer-Human Interaction. arXiv:2304.02491
Liffiton, M., Sheese, B., Savelka, J., & Denny, P. (2023). CodeHelp: Using Large Language Models with Guardrails for Scalable Support in Programming Classes. Koli Calling ’23. arXiv:2308.06921
Kazemitabaar, M., Ye, R., Wang, X., Henley, A. Z., Denny, P., Craig, M., & Grossman, T. (2024). CodeAid: Evaluating a Classroom Deployment of an LLM-based Programming Assistant that Balances Student and Educator Needs. CHI ’24. arXiv:2401.11314
Prather, J., Reeves, B. N., Leinonen, J., MacNeil, S., Randrianasolo, A. S., Becker, B. A., Kimmel, B., Wright, J., & Briggs, B. (2024). The Widening Gap: The Benefits and Harms of Generative AI for Novice Programmers. ICER. https://doi.org/10.1145/3632620.3671116
Tankelevitch, L., Kewenig, V., Simkute, A., Scott, A. E., Sarkar, A., Sellen, A., & Rintel, S. (2024). The Metacognitive Demands and Opportunities of Generative AI. CHI ’24. https://doi.org/10.1145/3613904.3642902
Kumar, H., Musabirov, I., Reza, M., Shi, J., Wang, X., Williams, J. J., Kuzminykh, A., & Liut, M. (2024). Guiding Students in Using LLMs in Supported Learning Environments: Effects on Interaction Dynamics, Learner Performance, Confidence, and Trust. CSCW. https://doi.org/10.1145/3687038
Kazemitabaar, M., Huang, O., Suh, S., Henley, A. Z., & Grossman, T. (2025). Exploring the Design Space of Cognitive Engagement Techniques with AI-Generated Code for Enhanced Learning. IUI ’25. https://doi.org/10.1145/3708359.3712104
Stienstra, L., Mohamed, A., & Mohamed, M. (2025). Exploring GenAI as a Tutoring Tool: A Case Study in First-Year Computer Programming. ITiCSE ’25. https://doi.org/10.1145/3724363.3729060
Shah, A., Chernova, A., Tomson, E., Porter, L., Griswold, W. G., & Soosai Raj, A. G. (2025). Students’ Use of GitHub Copilot for Working with Large Code Bases. SIGCSE ’25. https://doi.org/10.1145/3641554.3701800
Garcia, R., & Craig, M. (2025). 20 Years Later: A Replication Study on Teaching CS1 Concepts. ACM Transactions on Computing Education. https://doi.org/10.1145/3730405
Whalley, J., Settle, A., & Luxton-Reilly, A. (2023). A Think-Aloud Study of Novice Debugging. ACM Transactions on Computing Education. https://doi.org/10.1145/3589004
Fisler, K. (2014). The Recurring Rainfall Problem. ICER ’14. https://doi.org/10.1145/2632320.2632346
Watson, C., & Li, F. W. B. (2014). Failure Rates in Introductory Programming Revisited. ITiCSE ’14. https://doi.org/10.1145/2591708.2591749
Bennedsen, J., & Caspersen, M. E. (2007). Failure Rates in Introductory Programming. ACM SIGCSE Bulletin. https://doi.org/10.1145/1272848.1272879
Porter, L., & Zingaro, D. Learn AI-Assisted Python Programming, Second Edition: With GitHub Copilot and ChatGPT. Manning (Function). Kindle Edition. Available via IUCAT, Bloomington and Indianapolis campuses: ebook https://iucat.iu.edu/catalog/20590350, streaming audio https://iucat.iu.edu/catalog/21587005
Novet, J., & Vanian, J. (2025, April 29). Satya Nadella says as much as 30% of Microsoft code is written by AI. CNBC.
Consortium for Generative AI in CS Education, UC San Diego CREATE. Faculty leads: Leo Porter, Daniel Zingaro, Beth Simon. https://www.teachcswithai.org/
Porter, L. Research on GenAI and Learning To Program [Video]. YouTube. https://www.youtube.com/watch?v=faY5gDTlvs0
BOOKS ON Joyful Teaching
In recent months, faculty across higher education have been grappling with unprecedented challenges: from navigating rapid technological changes and AI integration to addressing student mental health concerns and institutional pressures that often feel overwhelming. Yet amid these difficulties, educators are increasingly recognizing that joy, care, and hope aren't luxuries in teaching, they're essential to sustainable, transformative pedagogy.
This spring, as we move through another semester of complex demands, one instructional designer reached out to a vibrant community of faculty educators on a teaching and learning mailing list via the POD Network, seeking uplifting book recommendations for a faculty book club focused on joyful teaching. The response was inspiring: a treasure trove of resources that collectively argue for teaching as an act of hope, care, and human flourishing.
What makes this moment particularly ripe for these conversations? We're at a crossroads where burnout threatens to become endemic, where students are navigating their own crises of belonging and purpose, and where institutions are being called to reimagine their core commitments. The books recommended by this community offer not empty optimism, but research-informed, practice-grounded pathways toward creating classroom environments where both students and faculty can truly thrive.
Essential Reads for Joy-Centered Teaching
Joy-Centered Pedagogy in Higher Education: Uplifting Teaching and Learning for All
Lori Gonzalez, Editor
(Open Access)
(https://doi.org/10.4324/9781003532224)
This collaborative collection stands out not only for its accessibility, it's completely open-access, but for its practical wisdom. Editor Lori Gonzalez has structured the volume with "reader reflection" questions at the end of each chapter and a compilation of teaching tips that serve as perfect discussion fodder for book clubs. Currently leading a book group on this text, Gonzalez notes that she's "chunked" chapters together thematically to facilitate deeper conversation. The beauty of this resource is that it doesn't just theorize joy; it provides concrete pathways to implement joy-centered practices across diverse educational contexts.
A Pedagogy of Kindness
by Catherine Denial
https://www.oupress.com/9780806193854/a-pedagogy-of-kindness/
This book emerged repeatedly in the recommendations, with one educator noting they "can't recommend it highly enough." Another shared that their Early Career Learning Community recently completed the book, which "prompted us to challenge our assumptions about 'rigor' and 'good teaching' and to rethink our classroom practices to foster meaningful learning, and student and faculty success." During the initial pandemic year, faculty found solace in Kevin Gannon's Radical Hope, which Denial's work extends and deepens. A Pedagogy of Kindness by Denial was also specifically recommended for its ability to reframe what we mean by rigorous, meaningful education.
Institutional Transformation and Care
Hope Circuits: Re-wiring Universities and Other Organizations for Human Flourishing
by Lee Skallerup Bessette (McGill–Queen's University Press, 2024)
(Available with discount code MQ25)
https://www.mqup.ca/hope-circuits-products-9780228020677.php
Written precisely for educators "trying to do hopeful, joyful, justice-oriented work inside institutions that often feel like they're fraying," Bessette's book tackles the gap between our aspirations for higher education and institutional realities. This book is particularly valuable for those who want to think beyond individual classroom practices to consider how institutions can be restructured to support human flourishing at every level.
The Caring University
by Kevin McClure
https://www.press.jhu.edu/books/title/53820/caring-university
McClure provides a research-informed account of how institutions can center care—not as empty rhetoric, but as "a set of practices, structures, and leadership habits that make joy and belonging possible for students, staff, and faculty." At a time when care is often dismissed as soft or secondary to academic rigor, McClure makes the compelling case that care is fundamental to educational excellence. Multiple educators in the discussion highlighted this as particularly relevant for current institutional challenges.
The Science and Practice of Emotional Engagement
The Spark of Learning: Energizing the College Classroom with the Science of Emotion
by Sarah Rose Cavanagh
Cavanagh's central argument is elegantly simple yet profound: emotions are contagious, and "conveying passion, enthusiasm, and love for learning in the classroom is the best route to motivating student engagement and thus learning." While acknowledging the book is "getting a little long in the tooth," its core insights remain powerfully relevant. This text serves as foundational reading for understanding how joy operates neurologically and socially in learning environments.
The Joyful Online Teacher: Finding Our Fizz in Asynchronous Classes
by Flower Darby (forthcoming April 2026)
https://www.amazon.com/Joyful-Online-Teacher-Finding-Asynchronous/dp/080619653X
Extending Cavanagh's work into the specific context of asynchronous online learning, Darby addresses what many see as particularly "joy-less" educational spaces. However, the author notes that "the research and theory I present is applicable in all classes, not just online. Many of the concrete tips I suggest can be adapted for in-person and synchronous online classes as well." This book acknowledges Darby’s influence while demonstrating how joy-centered pedagogy must adapt to evolving educational modalities.
The Present Professor: Teaching, Engaging, and Thriving in Higher Ed
by Elizabeth A. Norell
https://www.oupress.com/9780806194691/the-present-professor/
At a time of crisis in higher education, as teachers struggle to find new ways to relate to, think about, and instruct students, this book holds a key. Implementing more inclusive pedagogies, Norell suggests, requires sorting out our own identities. In short, if we want to create spaces where students have the confidence, comfort, and psychological safety to learn and grow, we have to create spaces where we do, too. The Present Professor is dedicated to that proposition, and to helping educators build that transformational space..
The Work of Peter Felten and Mays Imad
The discussion included strong recommendations for "literally anything by Peter Felten," particularly his scholarship on relationship-rich education and high-impact educational practices that "consistently brings together rigor, humanity, and a deep commitment to student–faculty partnerships." Similarly, educators highlighted the work of Mays Imad, "an incredible collaborator and curator" whose focus on "care, trauma-informed and hope-centered pedagogy, and the emotional/relational dimensions of teaching in times of crisis" offers essential frameworks for "how to hold both distress and joy in our classrooms."
Practical Resources and Creative Inspirations
For book clubs seeking supplementary materials, one educator recommended a "sweet little book of joy-filled teaching practices" compiled by colleagues at Dartmouth's Design Initiative—[available here as a PDF]. While not necessarily a traditional book club selection, it provides "fun, practical techniques" to energize discussions. Some educators have found joy by moving "outside the typical teaching and learning fare" to explore books like The Art of Gathering or Unreasonable Hospitality, which offer fresh perspectives on creating meaningful, joy-filled shared experiences.
Why These Books Matter Now
What emerges from this rich collection is a vision of teaching that refuses to choose between rigor and care, between justice and joy, between individual practice and institutional transformation. These authors collectively argue that in times of crisis and complexity, joy isn't a distraction from serious pedagogical work; it's essential to it.
As we navigate the remainder of this academic year and plan for the next, these resources offer not just inspiration but practical wisdom for creating classrooms and institutions where everyone can flourish. Whether you're grappling with how to integrate new technologies ethically, working to support students through multiple crises, or simply trying to sustain your own passion for teaching, this curated list, compiled by experienced educators committed to teaching and learning, provides pathways forward grounded in both research and deep care for the educational endeavor.
The timing couldn't be better to gather with colleagues, pour some coffee or tea, and explore together what it means to teach joyfully in challenging times.
Again, this list was compiled from recommendations shared by faculty educators on a mailing list dedicated to teaching and learning in higher education. Special thanks to all the contributors who generously shared their expertise and favorite resources.
Possible ways to improve attendance
One of the most frequent concerns I hear is, “My students just aren’t coming to class.” With so much content available online, recorded lectures at their fingertips, and the sense of distance that can come with large classes, this challenge is becoming more common and more complex. In this post, I will look at some of the more popular reasons reported for students not attending class and share practical, evidence-based ways to re-engage students in the classroom.
The Anonymity Epidemic: When Students Feel Like Just Another Face
Many students, particularly in large enrollment courses, feel anonymous. They don’t believe their individual presence makes a difference, leading to a disengagement from the classroom community. This isn’t just a large-class problem; it arises when students lack meaningful connections with instructors, TAs, or even their peers. Overcoming this anonymity is key to fostering a sense of responsibility and belonging.
Strategies to Combat Anonymity:
Be Present Before Class: Arriving early to chat informally with students is a simple yet powerful way to build rapport. Ask about their weekend, recent movies, or even their experience with the last assignment. These small gestures humanize you and create a connection.
Active Engagement is Key: Design activities that actively involve students with the material. Pose intriguing questions, facilitate brief peer discussions, or utilize classroom response systems like TopHat https://uits.iu.edu/tophat/index.html to “vote” on responses. This transforms passive listening into active participation, fostering an intellectual community.
Learn Their Names (or Try): Even the attempt to learn student names is deeply appreciated. Ask for names when students speak and use them in your response. Consider using a photo roster from Canvas to help you put names to faceshttps://toolfinder.iu.edu/tools/iu-photo-roster. A study in a high-enrollment biology course found that students’ perception of their instructor knowing their name was highly correlated with a sense of belonging, even though the instructors didn’t know every student’s name https://www.lifescied.org/doi/full/10.1187/cbe.16-08-0265 This suggests that the effort and intention behind using a student’s name are just as important as the memorization itself. For more strategies see: https://teachinginhighered.com/podcast/how-to-learn-students-names/
Cultivate Peer Connections: Encourage students to get to know each other. In in Relationship-Rich Education: How Human Connections Drive Success in College(Felten & Lambert, 2020) https://iucat.iu.edu/catalog/19430355mention that students benefit when they are guided in how to connect, not just told to “work together.” On the first day, have them introduce themselves to those around them. Additional strategies might include teaching collaboration skills, establishing norms for group work, or prompting reflection on what makes a partnership effective. If you use group work, rotate group members throughout the semester. Periodically have students shift seating to broaden their peer interactions.
Personalized Feedback (Even in Large Classes): While challenging, finding ways to provide even small amounts of personalized feedback on assignments can significantly reduce feelings of anonymity. This could be through targeted comments on a rubric or brief, individualized responses to discussion forum posts. In large classes, it’s impossible to give every student a paragraph of detailed feedback each week, but you can make feedback feelpersonal by thinking in layers. I like to frame it as macro, meso, and micro feedback. At the macro level, I share short announcements summarizing class-wide trends; what students are doing well, what’s tripping them up, and a few standout examples. At the meso level, I provide targeted feedback to lab sections, project teams, or discussion groups that speaks directly to their shared progress. Then at the micro level, I use rubrics and comment banks to individualize comments just enough to sound human…adding a student’s name or referencing something specific from their work. It’s not about writing more; it’s about being intentional with how students experience the feedback they receive.
The “Why Bother?” Dilemma: Lack of Incentive, Relevance, and Engagement
Students often skip lectures if they perceive the content as readily available elsewhere, not directly relevant to their goals, or simply boring.
Strategies to Create Incentive and Relevance:
Incentivize Attendance: Leverage students’ natural focus on grades. Make attendance a component of the grade, or administer short, low-stakes quizzes at the beginning of class using tools like Canvas or TopHat.
Design Slides to Drive Presence:Explicitly state that your posted slides are incomplete. Design them as skeletal frameworks, requiring students to annotate and fill in critical explanations and examples during lecture. This creates a clear value proposition for attending.
Debunk the “Notes from a Peer” Myth:Directly address the inadequacy of relying solely on peer notes or even AI-generated summaries. Emphasize that context, instructor insights, and the organic flow of a live lecture cannot be fully replicated.
Connect to Their World: Embed examples, applications, and topics that resonate with students’ fields of study and current cultural interests. Utilize Canvas Course Analytics, Reports and Dashboardsand/or pre-course surveys to understand your student demographics and tailor examples accordingly.
Pique Interest from the Start: Begin lectures with a challenging question, an intriguing anecdote, or a real-world problem that immediately grabs attention and motivates sustained engagement.
Convey Your Enthusiasm: Your passion for the subject is contagious! Share personal stories, recent discoveries, and your excitement for the discipline. Voice and body language naturally convey this enthusiasm.
Overcoming Information Overload and Misaligned Expectations
Sometimes, students skip because they feel overwhelmed, confused by lecture goals, or perceive the lecture as redundant to textbook material.
Strategies for Clarity and Complementary Learning:
Chunk Your Lectures & Re-engage:Recognize that typical attention spans are 10-20 minutes. Plan your lectures in shorter chunks, incorporating varied activities every 15-20 minutes to re-engage attention (e.g., questions, visuals, demonstrations, group work, videos). Consider attending the upcoming Active Learning Block Party for Large Classrooms sponsored by CITL for engagement ideas.
Complement, Don’t Reiterate, the Textbook: Use class time to expand on readings, provide alternative perspectives, facilitate problem-solving, or have students generate their own examples. The lecture should offer something the textbook doesn’t.
Provide Unique Experiences: Bring in guest speakers, conduct live demonstrations of code or hardware, or share cutting-edge research and innovations that students wouldn’t encounter elsewhere that connect with course content.
State Your Goals Clearly: Explicitly articulate the learning objectives for each lecture. Use these goals as “mileposts” to help students track their progress and understand the desired outcomes.
Share the Organization: Provide an outline, agenda, or visual representation of the lecture’s structure. Don’t assume novices will automatically see the logical connections among concepts.
Encourage Support Services: If you identify students struggling with academic or non-academic demands, refer them to appropriate support services like Academic Development, the Counseling Center, or Student Health. Student Resource Slideshow.pptx
Support Language Learners: For students whose first language is not English, refer them to resources like the Office of International Services which offers drop-in English tutorials for second language students https://ois.iu.edu/get-involved/english-tutorials/index.html
Provide Recordings (Strategically):While recordings can reduce attendance, they are a valuable accessibility tool. If you record, emphasize that the recording is a supplement for review or for those with legitimate absences, not a substitute for live engagement. Consider how you might make the live session distinctly more valuable than the recording (e.g., interactive elements through PlayPosithttps://uits.iu.edu/services/technology-for-teaching/instruction-and-assessment-tools/playposit/index.html, Q&A).
The Power of Visuals and Storytelling
In fields like Computer Science and Engineering, abstract concepts can be difficult to grasp. Visuals and real-world narratives can significantly enhance comprehension and engagement.
Additional Tips:
Integrate Visualizations: When explaining complex algorithms, data structures, or system architectures, use diagrams, flowcharts https://miro.com/, and animations Show, don’t just tell. Consider generating some of these visualizations on the fly with your students!
Tell Stories of Impact: Frame technical concepts within the context of real-world problems they solve or innovative applications. How did this algorithm enable a new technology? What societal problem does this data science technique address?
Live Coding Demonstrations: For programming or data manipulation courses, live coding is incredibly effective. It allows students to see the process, observe debugging strategies, and ask questions in real-time. Make sure to slow down and explain your thought process.
Guest Speakers from Industry: Invite professionals from relevant industries to share how the concepts taught in class are applied in their day-to-day work. This provides tangible career relevance.
By adopting these evidence-based strategies, faculty can transform their lectures from passive information dissemination into vibrant, engaging learning experiences that students genuinely want to attend. The goal isn’t just to fill seats, but to foster deeper learning and a stronger connection to the academic community.
The Guide on the Side: Coaching STEM Students in Problem-Solving
From Manager to Mentor: A Practical Strategy for AI Development
As faculty, we know that working effectively with our Assistant Instructors (AIs) is key to a successful course. In last week’s post on “Best Practices for Working with Assistant Instructors,” I highlight the importance of mentorship and creating professional development opportunities. But what does that mentorship look like in practice?
One of the most impactful ways to mentor our AIs is to equip them with high-leverage teaching strategies. Instead of just managing their grading, we can teach them how to teach. A powerful approach for this is the “Guide on the Side“ philosophy, which shifts the AI’s role from a simple answer-key to a learning coach.
The Guide on the Side: Coaching STEM Students in Problem-Solving
It’s a familiar scene in any STEM lab or office hour: a student, staring at a screen, is utterly stuck. For new teaching assistants (Associate Instructors, or AIs), the temptation is strong to take the shortcut; to grab the keyboard, write the line of code, or simply provide the answer. But while this solves the immediate problem, it bypasses a crucial learning opportunity.
This is where the Guide on the Side approach comes in. It’s a teaching philosophy that equips new AIs with practical strategies to coach students through the problem-solving process rather than solving problems for them. For faculty in STEM, empowering your AIs with these skills can transform your students’ learning experience.
Why This Shift in Pedagogy Matters
Across STEM disciplines, students frequently encounter “sticking points” moments of cognitive friction where the path forward isn’t obvious. If an instructor or AI simply hands over the solution, the student leaves with a single answer but no transferable skill. They learn to be dependent on an external expert.
By contrast, an instructor who guides the process models resilience, inquiry, and expert reasoning. The student leaves not only with a solution but with strategies they can apply to the next problem, and the one after that. They learn how to think.
Putting Theory into Practice: Activities for Your AIs
Faculty can use these activities in their own training sessions to help AIs develop a coaching mindset:
“Sticking Point” Brainstorm: In a think-pair-share format, AIs identify the most common places their students struggle. This builds a shared awareness of teaching challenges and normalizes the experience.
Scenario Analysis: AIs compare two contrasting dialogues: one where the AI gives the answer directly, and another where the AI uses Socratic questioning to lead the student to their own solution.
Questioning Roleplay: In pairs, AIs practice how to respond with guiding questions when students make common statements like, “I’m totally lost,” or “Can you just tell me if this is right?”
A Simple Framework for Modeling Expertise
A core strategy of this approach is teaching AIs to make their thinking visible. Experienced problem-solvers naturally follow steps that are often invisible to novices. Encourage your AIs to narrate their own problem-solving process explicitly using a simple four-step framework:
Understand: Restate the problem in your own words. What are the inputs, the desired outputs, and the constraints?
Plan: Outline possible approaches. What tools, algorithms, or libraries might be useful? What are the potential pitfalls of each approach?
Do: Execute the plan step by step, narrating the reasoning behind each action. (“First, I’m going to create a variable to hold the total because I know I’ll need to update it in a loop.”)
Reflect: Test the solution. Does it work for edge cases? Could it be more efficient? Are there alternative ways to solve it?
This explicit modeling teaches students how to think, not just what to do.
The Power of a Good Question: Building a Question Bank
Guiding questions are the primary tool of a “Guide on the Side.” They skillfully shift the cognitive work back to the student. Encourage your AIs to build a bank of go-to questions, such as:
To start a conversation: “What have you tried so far?” or “Can you walk me through your current approach?”
To prompt a next step: “What does that error message suggest?” or “What’s the very next small step you could take?”
To encourage deeper thinking: “Why did you choose that particular method?” or “What are the trade-offs of doing it that way?”
To promote reflection and independence: “How could you check your answer?” or “What would you do if you encountered a similar problem next week?”
Navigating Common Classroom Challenges
This approach provides concrete strategies for these common moments:
When a student is silent: Allow for sufficient wait time. If the silence persists, break the problem down and ask a simpler, first-step question.
When a student is frustrated: Acknowledge their feelings (“I can see this is frustrating; these problems are tough.”) and normalize the struggle before gently re-engaging with the task.
When a student just wants confirmation: Instead of giving a simple “yes” or “no,” redirect with a metacognitive prompt like, “What makes you confident in that answer?” or “How could you design a test to verify that?”
Resources for a Deeper Dive
For faculty and AIs who want to explore this pedagogical approach further, these resources are short, impactful, and highly relevant:
Book: Small Teaching: Everyday Lessons from the Science of Learning by James M. Lang
Article: Asking Questions to Improve Learning – Washington University in St. Louis Center for Teaching and Learning
Video: Eric Mazur’s video on Peer Instruction is a great resource for understanding how to shift from traditional lecturing to more active, student-centered learning. He effectively demonstrates the curse of knowledge and how students learning from each other can be more effective than an expert trying to explain something they’ve long ago mastered.
His approach, where students first think individually, then discuss with peers, and finally re-evaluate their understanding, directly aligns with the principles of guiding students through problem-solving rather than just showing them the answer. It emphasizes active processing and peer teaching, which are crucial for deeper learning and developing independent problem-solvers.
The Takeaway for Faculty
The “Guide on the Side” approach aligns perfectly with evidence-based teaching practices. By encouraging your AIs to slow down, model your thinking, and use questions effectively, you help them grow from being answer keys into becoming true teaching coaches. The result is a more engaged and resilient cohort of students who leave your courses not only with solutions, but with the confidence and strategies to tackle the next challenge independently.
Teaching Tip: What Are You Really Trying to Assess?
As you design quizzes, projects, and exams, it’s worth pausing to ask: What am I really trying to assess? Too often, assessments measure peripheral skills like memorization, rather than the intended learning outcomes. For example, a timed coding exam may end up evaluating typing speed and syntax recall more than algorithmic thinking or problem-solving strategy. Similarly, a multiple-choice exam on HCI principles may privilege memorization over the ability to apply design heuristics to new contexts.
Evidence-based practices to align assessments with your goals:
Backwards Design (Wiggins & McTighe, 2005)
Start with the outcome: Do you want students to demonstrate abstraction, debugging, empathy for users, or system-level thinking?
Then design an assessment that directly elicits that performance.
CS Example: Backward design: Integrating active learning into undergraduate computer science courses (2023) https://www.tandfonline.com/doi/epdf/10.1080/2331186X.2023.2204055?needAccess=true
Constructive Alignment (Biggs, 1996)
Ensure that learning activities, assessments, and outcomes are in sync. For instance, if collaboration is a stated goal, include a group design critique, not just individual tests.
Example: Reflections on applying constructive alignment with formative feedback for teaching introductory programming and software architecture (2016): https://dl-acm-org.proxyiub.uits.iu.edu/doi/pdf/10.1145/2889160.2889185
Authentic Assessment (Herrington & Herrington, 2007; )
Use real-world tasks (e.g., designing a database for a case study client, creating a usability test plan, or simulating an engineering design review). Research shows authentic assessments better support transfer of learning to workplace contexts. https://www.sciencedirect.com/science/article/pii/S0191491X24001044
Reduce Construct-Irrelevant Barriers
If the skill being assessed is debugging, for example, provide starter code so students aren’t penalized for setup. If the goal is conceptual understanding, consider allowing open-book resources so recall doesn’t overshadow reasoning.
Students also struggle not because the concepts are beyond their ability, but because the expectations of the assessment are unclear.
For example:
A programming assignment asks students to “optimize” code, but it’s unclear whether grading is based on correctness, runtime efficiency, readability, or documentation.
A human–computer interaction (HCI) project requires a prototype, but is the emphasis on creativity, usability testing, or fidelity of the mockup?
An informatics paper asks for “analysis,” but it’s unclear whether success depends on critical thinking, proper use of data, or following citation conventions.
When assessments lack clarity, students must guess what matters. This shifts the focus from demonstrating learning to playing a hidden “what does the professor want?” game.
Why It Matters (Evidence-Based):
Cognitive Load: Ambiguous assessments create unnecessary cognitive load—students waste energy interpreting instructions instead of applying knowledge (Sweller, 2011).
Equity Impact: Lack of clarity disproportionately disadvantages first-generation and other structurally disadvantaged students, who may not have tacit knowledge about faculty expectations (Winkelmes et al., 2016).
Misalignment: As mentioned above, vague assessments often misalign with course outcomes, undermining constructive alignment (Biggs, 1996).
What Faculty Can Do:
State the Core Construct: Ask yourself: Am I assessing correctness, creativity, reasoning, or communication? Then state it explicitly.
Communicate Priorities: If multiple criteria matter, indicate their relative weight (e.g., correctness 50%, efficiency 30%, documentation 20%).
Provide a Sample Response: A brief example—annotated to show what “counts”—helps students see what you value.
Check for Hidden Criteria: If you penalize for style, clarity, or teamwork, ensure that’s written down. Otherwise, students perceive grading as arbitrary.
Faculty Reflection Prompt:
Pick one upcoming assignment and ask yourself: If I gave this to a colleague in my field, would they immediately know what I was assessing? Or would they have to guess? If the latter, refine the task or rubric until the answer is obvious.
Takeaway: Unclear assessments don’t just frustrate students, they distort what is being measured. By clarifying exactly what skill or knowledge is under the microscope, faculty ensure assessments are fair, transparent, and aligned with learning outcomes. Before finalizing any assignment or test, ask yourself: Am I measuring the skill that truly matters, or something adjacent? That small moment of reflection can make assessments more equitable, meaningful, and aligned with the professional practices of your discipline.