When Code Is No Longer the Challenge
Aligning learning, assessment, and teaching with the realities of AI-assisted programming
Last summer, a group of us at the Dagstuhl Seminar on Generative AI in Programming Education began discussing how computing curricula should respond to AI-assisted programming. Our resulting Communications of the ACM opinion article, Computing Education When Writing Code Is No Longer the Challenge, is now available.
Taken literally, the title is not entirely new: software engineering has long involved much more than typing code, and implementation has often not been the main bottleneck. But generative AI makes that point newly consequential for education. Producing working code is becoming easier and faster, while the difficult work increasingly lies before and after generation: deciding what should be built, specifying it clearly, decomposing and orchestrating the work, and evaluating whether the result is correct, trustworthy, and useful.
Our central argument is not that programming no longer matters, or that foundational exercises have no value. It is that leaving our learning outcomes, assignments, and curricula unchanged will poorly serve students entering a world where AI-assisted development is routine. Students still need deep computing knowledge, but they will increasingly apply it through design, specification, verification, critical evaluation, and human–AI collaboration—not through code production alone.
This also raises a harder question that the article does not fully resolve: how central should code reading and writing remain? One plausible near-term response is to deemphasize writing code while continuing to teach students to inspect, debug, and improve generated code. But that may be a transitional model rather than the endpoint. If increasingly agentic systems can plan, implement, test, and revise across an entire development session, code-level review may stop scaling. We need better ways to teach students to judge computational artifacts that neither they nor any other person wrote line by line.
The difficult pedagogical question is how students develop that judgment. Foundational knowledge remains essential: students must be able to recognize errors, ask good questions, and intervene when automation fails. But we should not assume, without testing it, that the only way to acquire those capacities is through the same long sequence of code-writing exercises we have historically required. As automation absorbs more routine work, the remaining human decisions may become less frequent but more consequential.
That strikes me as one of the most urgent problems for computing education. The challenge is not simply teaching students to use generative AI in CS1. It is preparing them to supervise, constrain, verify, and take responsibility for computational systems operating with growing autonomy. It is also sustaining curiosity, independence of thought, and critical judgment when plausible answers are always readily available.
More broadly, this moment should push us to ask who computing education is for and what ends it serves. If building with computation no longer requires years of syntax-first preparation, many more people may be able to use computing to pursue ideas and solve problems. But access to tools is not the same as access to understanding. Whether this transition broadens participation or creates new forms of dependence will depend in part on how well we teach design, judgment, verification, and responsible use.
The article offers a framework for institutions that need to act now while also reconsidering their longer-term assumptions. We are not arguing that everything must be discarded: good teaching remains good teaching, and many existing program outcomes remain relevant. But the context in which students learn and practice computing has changed. Our curricula must change with it.