Teaching Programming in the Age of AI
This reflection stems from ongoing conversations with colleagues across computer science departments, as we collectively grapple with fundamental questions about how AI will (vs should) reshape our pedagogical approaches. I share these thoughts as an invitation for broader dialogue within the whole academic community.
Programming education feels stuck in a time warp. Most university courses still teach the way we learned: memorizing syntax, debugging cryptic error messages by hand, writing endless boilerplate code. Meanwhile, our students live in a world where AI can generate working code from simple descriptions. There's a real disconnect between how we're teaching and what students actually need to learn.
I, for one, learned recursion through these formal logical constructs:
That experience shaped my perspective, but over the years, our field has increasingly focused on reducing barriers to entry. I still remember my undergraduate cohort — about 80% of my colleagues struggled throughout the entire course, and many never finished. Significant efforts have been made in our community to reduce initial struggles through better tools and more accessible languages.
Today's students encounter programming through high-level languages like Python or JavaScript that embody what the programming language design community calls "low floor, high ceiling": they reduce entry barriers while maintaining the depth and capability that experts can leverage. Students can achieve meaningful progress within hours rather than weeks, reflecting decades of intentional design work in accessible programming education.
The real issue isn't that AI makes programming easier — it's that our traditional teaching methods can now create an artificial barrier. When students know AI can generate working code from natural language, asking them to struggle with syntax memorization feels like busy work rather than meaningful learning.
This connects to research on "flow" states, that sweet spot where learning happens when tasks are challenging but not overwhelming. Programs like the Hour of Code have shown this works well for getting people started with programming.
Traditional flow state optimization balances skill and challenge for sustained learning engagement.
AI changes this balance completely. Things that used to require real skill (handling complex syntax, deciphering error messages, writing boilerplate code) AI now does routinely. This creates a new scenario: the old "flow" becomes AI territory, and keeping students engaged means pushing toward higher-level challenges that focus on genuinely human skills like breaking down problems, understanding code, and designing systems.
AI assistance shifts the traditional flow channel, requiring programming education to target higher-level challenges for optimal learning engagement.
As AI assumes responsibility for syntax and boilerplate generation, programming education must evolve to cultivate the analytical and design capabilities that distinguish exceptional developers from sophisticated code generators.
While we're seeing this shift across many institutions, we need more research to figure out the best transition strategies rather than just sticking with what we've always done.
Greg Wilson makes an important point in "Teaching Tech Together": you are not your learners. We naturally teach from our own experiences, thinking the struggles we went through will help our students. He calls this the "expert blind spot" — experienced programmers often miss what beginners actually need. Yet in programming classes, we often stick to old approaches even as technology changes rapidly around us.
Look at what happened in mathematics education. When calculators first appeared, educators worried that students would lose essential computational skills. But instead of keeping things as they were and ignoring it, the field became more strategic. We still teach core concepts that need human understanding: multiplication tables in elementary school, calculus in high school. The shift happened in emphasis. Rather than focusing on computational mechanics, we shifted toward teaching strategy. Students learn which tools work for different problems, how to approach complex solutions step by step, when to apply different strategies, and why certain methods work better than others.
Programming education faces a similar inflection point: transitioning from syntax memorization toward developing robust computational thinking and strategic problem-solving capabilities.
New Competencies for AI-Integrated Programming
In AI-enhanced programming environments, several skills should become increasingly critical:
Code comprehension and evaluation: Rapidly analyzing, understanding, and assessing AI-generated code to identify strengths, limitations, and improvement opportunities.
Precise problem formulation: Clearly defining and decomposing complex problems so AI tools can provide genuinely useful assistance.
Systematic testing and validation: Methodically identifying issues in generated solutions and verifying that implementations actually address intended problems.
Systems-level thinking: Understanding component interactions, scaling considerations, and integration challenges within larger software architectures.
Live coding remains pedagogically valuable but can evolve into "live problem-solving" demonstrations. Rather than passively observing instructors write code, students actively engage with problem decomposition processes, solution refinement strategies, systematic testing approaches, debugging methodologies, and system integration techniques. This approach mirrors professional programming practices while developing students' analytical capabilities.
Rubber-duck debugging is another example of how traditional techniques can be updated for this new reality. The classic approach involves explaining code line-by-line to an inanimate object (literally a rubber duck) to force systematic thinking through problems. The act of articulation often reveals bugs that weren't obvious during coding. We can now enhance this with AI as an interactive debugging partner. Students explain their code to an AI that responds thoughtfully, asking clarifying questions, suggesting edge cases to consider, and helping them articulate their reasoning process. Rather than providing direct solutions, the AI acts as a 'provocateur' — challenging assumptions and stimulating deeper critical thinking about the code's logic and design.
Peer instruction becomes particularly powerful in this context. Students deepen understanding through collaborative discussions about problem-solving approaches, requirement clarification, issue identification, and solution validation. These interactions become even richer when students collectively examine and enhance AI-generated code.
Honoring Experience While Embracing Evolution
Our experiences provide valuable foundations that shouldn't be discarded wholesale. Wilson's reminder that "You are not your learners" doesn't call for abandoning everything we've learned, but rather for thoughtfully adapting our approaches. The goal isn't to throw out decades of pedagogical wisdom, but to evolve our methods in response to changing technological realities.
Traditional programming education has successfully prepared developers for decades, and many of its core principles remain sound. The systematic thinking, problem decomposition, and logical reasoning we've always emphasized are more important than ever. What needs updating is how we cultivate these skills and what tools we use to develop them.
Like most fields facing technological disruption, programming education must evolve from its existing foundation rather than starting from scratch. By building on our understanding of computational thinking while integrating AI as a collaborative tool, we can prepare students not merely to use new technologies, but to excel in environments where critical thinking and strategic problem-solving distinguish exceptional programmers.
Just as mathematics education became stronger by building on solid foundations while thoughtfully integrating calculators, programming education can improve by preserving what works while adapting to AI-enhanced environments. The evolution isn't about replacement — it's about responsive adaptation that honors our pedagogical heritage while preparing students for tomorrow's challenges.
I'd love to hear your thoughts — reach out to keep the conversation going.