The New Computing

Abstract

Abstract

AI is transforming computing, education, and society. As computing educators, we have a particular responsibility in this moment—to work through the uncertainty and prepare graduates who can shape the AI era. That requires rethinking not just how we teach, but what we teach: the very content of our assignments, courses, and degree programs. This ~15-minute talk closes a one-day workshop at Constructor University on AI in computer-science education, and walks through three redesigns already underway at Illinois—an assignment, a course, and a degree—organized around a single hypothesis: that AI collaboration is a distinct skill, independent of but related to classical programming.

Summary

Summary

The closing talk of Constructor University’s workshop on the influence of AI on CS education, delivered virtually from Illinois to Bremen. By the end of the day the novelty and importance of the technology were well established, so the talk opens not with grand claims but with credibility—twenty-five years of writing code by hand, and the admission that I now build completely differently—and frames the moment, after David Rosenblum’s opening, as a crisis in the old sense: danger and opportunity together. It then walks through concrete steps at three scales: a Spring 2026 redesign of CS 124 around independent, AI-collaborative student projects graded on time-on-AI; a new course, Using and Understanding AI, built entirely through conversational programming and assessed by oral assessment at scale; and a draft Applied Computing degree inspired by architectural pedagogy. The throughline is a hypothesis—that AI collaboration is a skill of its own—and the talk closes by returning to computing’s pioneers, whose seventy-year-old dreams we may finally be able to deliver.

Twenty-five years of code

Twenty-five years of code

Earlier speakers had already established that AI is a big deal, so the talk skips the windup and establishes credibility instead. For twenty-five years I wrote code by hand—operating systems, wireless sensor networks deployed on active volcanos, the world’s first smartphone-platform testbed, the infrastructure behind my courses—four days out of five, sustained. Since 2026 I no longer read, write, or debug code by hand, and I am building more than ever. I code completely differently now, and that change is what the rest of the talk is about.

David Rosenblum opened the day with a word: crisis. I lean on the old, apocryphal reading—danger and opportunity in one character—not because it is etymologically correct, but because it is apt. The rest of the talk is the opportunity.

Assessments: CS 124

Assessments: CS 124

The traditional model of a programming assignment: write a specification, hand it to students, they translate it into code, I grade the code against the spec. In July 2025, with Claude Code, I sat down with the multi-week Android assignment we give CS 124 students and watched—with only the test suites in hand, not even the prose specification—as Claude completed the entire thing in an hour. The shape of assignment we had used for decades broke that afternoon. The assignment was always a specification, and producing the artifact a specification describes is exactly what AI is best at.

We tried a partial fix in Fall 2025: blur the spec, give students less to hand to AI. It failed. The information students need to fairly complete an assignment is enough information for AI to complete it too.

So this spring, every one of ~400 CS 124 students designed and built their own Android app with Claude Code. The hard part of working with a coding agent isn’t generating code—it’s getting the idea out of your head into a specification the agent can follow. The course scaffolds that work, and because no two projects are the same, we grade for time on AI, instrumented from session logs, with AI itself distinguishing substantive engagement from off-task chatter. Classical programming fundamentals stay rigorous in parallel: fifteen hours of proctored testing per semester in the Illinois computer-based testing facility, frequent small assessment, and rolling retakes. None of this works without that institutional infrastructure—the bottleneck on better assessment is rarely the idea, it’s the facility to run it for real, at scale, securely.

Courses: conversational programming

Courses: conversational programming

This year I launched Using and Understanding AI, a new course on generative AI for non-technical students—no prerequisites, no code. Its infrastructure was built entirely through conversational programming: I did not manually read, write, or debug a single line of the code that powers the site, across 199 sessions, 4,038 turns, and 29,770 tool calls.

The piece I am most excited about pedagogically is conversational assessment: the chat-based equivalent of an oral exam. The oral exam is a gold standard—you cannot fake understanding in a real conversation—it just never scaled. Now it does. An interviewer agent talks with the student while an evaluator agent watches the rubric; we validated it against adversarial personas, the hardest to defeat being the confident bullshitter. The result is oral assessment that is scalable, high-frequency, and auditable. Several students kept building beyond the course—one replaced the apps her sorority pays for; another, an aquascaper, built a tracker for tanks, livestock, plants, water chemistry, and maintenance.

In Fall 2026 I am piloting Conversational Programming, a course built around conversation as the programming interface—which is exactly what Paolo Ciancarini meant this morning when he said the conversation is the computer. The idea is not new: a generation of work on “conversational programmers” (Chilana, Guzdial, Cunningham; and Hur & Cunningham’s recent finding that it is the single most popular endpoint for non-CS majors) studied students who learned to talk to coders. The difference now is that the partner is a machine, and the student owns the intent, the specification, and the verification.

The deeper point: the oldest defect in software is that the person who cared about a problem and the person who could change the artifact were two different people, joined by a lossy requirements channel. Agents collapse that split. What’s left for the human is judgment—a kind of epistemic discipline. The course is organized around a trust gradient: at one end the agent is boringly reliable (syntax, scaffolding, hygiene); in the middle are the traps where a green check lies (100% coverage of the code the agent wrote, accessibility a real user still can’t navigate); at the far end are the things only the human can own (the threat model, the user model, what is worth building). We grade the delta—what the student adds beyond what the agent surfaced. And we run it like an architecture studio: a portfolio of small, disposable projects that converge on one user-anchored final, where the work is to make it right, which usually means smaller.

My hypothesis

My hypothesis

The talk names its throughline explicitly: AI collaboration is a distinct skill—independent of, but related to, classical programming. The prevailing view treats them as stacked—learn to code first, then you can build with AI. I suspect they are independent. In both worked examples, most of the value came from decomposing the problem, directing the AI, and judging its output—not from reading or writing source code. The honest caveat: every result we have was measured on students taught code-first, so no one has actually run the other experiment yet. I argue this at length in Another Skill.

Degrees: Applied Computing

Degrees: Applied Computing

Two populations of computing students have come into focus. Some want to understand computing—the theory, the internals, the depth. Some want to use computing to solve problems in the world. Not categories—dimensions; most students mix. CS degrees today serve the first population well, the second only obliquely.

Applied Computing is a draft undergraduate degree for the second population. The core leans on conversational programming first, classical programming later—fluency first, then the move backward to reason about the systems underneath. Outside the core, three pillars: a domain concentration via any existing minor, formation through writing, literature, moral reasoning, and studio art, and a studio progression run as a portfolio model—students graduate with a body of work, not a transcript, defended in public. Much of this is borrowed from architectural pedagogy, the original union of art and science—a union embodied by Constructor’s own president, a Nobel physicist who paints with graphene and Chinese ink. The section closes on Stewart Brand: in 1968, “we are as gods, we might as well get good at it”; in 2009 he changed the verb to “have to.”

History rhymes

History rhymes

The talk returns, at the close, to five quotes from computing’s pioneers. Grace Hopper wanted people to write their programs in plain English. J.C.R. Licklider imagined computers devising their own procedures from stated goals. John Kemeny envisaged millions of people writing their own software. Edsger Dijkstra and Joseph Weizenbaum sounded the cautions. 1955 to 1976. The dreams are seventy years old, and for the first time they look deliverable.

Closing thoughts

Closing thoughts

Four takeaways. Change our work, and ourselves—new assessments, courses, and degrees, and educators who keep learning. Use the tools to know the tools—you only learn what they can do by building with them. Embrace the uncertainty—AI collaboration is a new skill, and we don’t yet know how to teach it, so we need a lot of people trying a lot of new things. And deliver the future: tech without the tech companies, the ultimate fulfillment of the dreams of computing’s pioneers.

Thanks to David Rosenblum for the invitation, Giancarlo Succi and the School of Computer Science and Engineering, co-chair Jürgen Schönwälder, organizer Stella Byun, and everyone in Bremen and online.