AI coding assistants have reshaped how developers write software, and computing educators are scrambling to respond. A forthcoming viewpoint in Communications of the ACM from three prominent computer scientists argues that the disruption is not a crisis but a chance to rebuild introductory curricula around what students actually need to learn in an age of AI agents.
The Flaky Compiler Metaphor
Kathi Fisler, Shriram Krishnamurthi, and Michael Littman introduce a framing device they call the "flaky compiler." Traditional compilers are deterministic: given the same source code, they produce identical output every time, and when they fail, the errors are predictable and fixable. AI programming agents behave differently. They can generate plausible code that sometimes works and sometimes does not, introduce subtle bugs that pass casual inspection, or produce different solutions to the same prompt across multiple attempts.
The metaphor reframes how instructors should think about AI tools in the classroom. A flaky compiler is not useless, but it demands a different workflow from its user. Developers working with such a system must verify outputs, reason about specifications, and maintain a clear mental model of what the code should do before trusting what the agent produced. These are exactly the skills that introductory courses have historically deferred to later semesters.
Why Intro Courses Must Shift Toward Software Engineering
For decades, the first programming course has focused on syntax, control flow, and basic algorithms. Students learn to write loops, handle conditionals, and debug small programs. That model assumed the bottleneck was producing code. AI agents have erased that bottleneck for many routine tasks. A student can describe what they want in plain English and receive functional code in seconds.
What has not disappeared is the need to understand whether the generated code does what it claims, whether it handles edge cases, and whether it integrates correctly with a larger system. These are software engineering concerns: specification, testing, integration, and accountability. The authors argue that introductory courses must pivot to teach these competencies from day one, rather than treating them as topics for upper-level electives.
This is not about removing programming from introductory courses. Students still need to read code, modify it, and reason about its structure. But the emphasis shifts from "can you write a for loop from scratch" to "can you specify what this function must do, evaluate whether an AI-generated implementation meets that specification, and fix it when it does not."
Teaching Specification as a Core Skill
The paper highlights a specific research gap: how to teach program specification to novice learners. Specification means writing precise descriptions of what a program should accomplish, independent of how it is implemented. In professional software engineering, specifications drive testing, code review, and formal verification. In classrooms, they have mostly been an afterthought.
AI agents make specification urgent. A developer who cannot articulate clear requirements has no way to evaluate whether agent-generated code is correct. The authors call for research into pedagogical approaches that introduce specification early, in ways accessible to students who are just learning to program. This might involve lightweight formal methods, structured testing frameworks, or new abstractions that bridge natural language intent and executable code.
Michael Littman, a leading AI researcher at Brown University, brings particular weight to this argument. His work on reinforcement learning and multi-agent systems gives him direct insight into what AI coding tools can and cannot do reliably. Shriram Krishnamurthi, also at Brown, is known for his work on programming languages education and has long advocated for teaching the principles behind code, not just the mechanics. Kathi Fisler, at Brown as well, specializes in curriculum design and has spent years developing approaches to teach complex computing concepts to beginners. The combination of expertise on this paper lends credibility to the prescription.
What This Means for Educators and Students
For instructors, the practical takeaway is clear: curricula built around rote syntax drills are preparing students for a world that no longer exists. Courses should incorporate AI tools explicitly, not as forbidden shortcuts but as part of the workflow students must learn to manage. That means building assignments around specification writing, code review, testing, and debugging AI output rather than hand-writing every line from memory.
For students, the message is that AI does not eliminate the need to understand computing. It changes what understanding looks like. A student who can prompt an AI to generate a sorting algorithm but cannot explain whether the algorithm handles duplicate keys correctly has not learned enough. The value shifts from production to judgment.
For the broader computing education community, the paper is a call to invest in research. The authors are not prescribing a specific curriculum. They are identifying a problem space that needs rigorous exploration: how do you teach specification, verification, and responsibility to people who are simultaneously learning what a variable is? The answers will shape the next generation of computing education.
The viewpoint is accepted for publication and is expected to appear in the November 2026 issue of Communications of the ACM. It arrives at a moment when universities worldwide are debating how to respond to AI in the classroom, offering a framework that treats the technology as an catalyst for deeper learning rather than a reason to lower expectations.