The New Computing

2026-06-29
Workshop on the Influence of AI on Education in Computer Science and Engineering, Constructor University, Bremen (virtual)
View Slides

Watch

The same talk in text: the summary below, then each slide with what I say.

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. 1958 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.

Slides

The New Computing

Slide 1: The New Computing

Thank you to David Rosenblum and the Constructor team for the invitation. I am glad to close the day, virtually, from Illinois. In about fifteen minutes I want to tie the day's threads to what we are actually building: three redesigns from this year, an assignment, a course, and a whole degree. One argument at three growing scales: assessments, courses, and degrees.

Slide 2: Twenty-Five Years of Code

Earlier speakers have established that this technology is a big deal, so let me tell you instead why you might listen to me about AI and code. This ribbon is my coding history. Four days out of five, for twenty-five years, I wrote code by hand to realize my educational visions: operating systems, wireless sensor networks deployed on active volcanos, the world's first smartphone-platform testbed, and the infrastructure behind my courses.

Then, in July 2025, the turn. 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 this talk is about.

Slide 3: Building the New Computing

This image carries the message: educators, not vendors and not administrators, building the next university with their own hands, with AI agents as the crew. A barn-raising, not a disruption. David opened today with a word: crisis, danger and opportunity in one character. That reading is apocryphal, but it is apt. The rest of my talk is the opportunity.

Assessments

Slide 4: Assessments

The first section is assessments, and its anchor is Grace Hopper, in the FLOW-MATIC manual in 1958: familiarity with detailed computer coding is not necessary. Plain-language programming is older than our field. This work is in collaboration with the CS 124 head tutors and the rest of our staff, more than fifty tutors and graduate tutors. The question is what assessment looks like when AI sits next to every student.

Slide 5: The Traditional Programming Assignment

Here is how a traditional programming assignment works. It starts with me, the instructor.

I have an idea for what students should build.

I turn that idea into a specification and hand it to the student.

The student translates the specification into a program and turns it in.

And I grade the program against the specification. The whole shape assumes that the student writes the code.

Slide 6: AI Does the MP

In July 2025, with Claude Code, I sat down with the multi-week Android assignment we give CS 124 students. With only the test suites in hand, not even the prose specification, Claude completed the entire thing in about an hour. This is that session, sped up thirty-two times. The shape of assignment we had used for decades broke that afternoon, and every student already has this capability.

Slide 7: The Programming Assignment, with AI

So here is the same pipeline today. The instructor still has the idea and still hands the student a specification.

But the student hands the specification straight to AI. The assignment was always a specification, and producing the artifact a specification describes is exactly what AI is best at.

The program comes back to me. The output looks the same; the work that produced it does not.

Slide 8: With or Without AI

That raises the diagnostic question: from the artifact alone, can you tell whether an assignment was done with or without AI?

Here is the traditional pipeline: a description, a result, a grade.

And here it is with AI: the same description, the same result, the same grade, with a collaboration loop in the middle that the instructor never sees. For most specification-based work, you cannot tell the difference. That is the assessment problem in one slide.

Slide 9: Fall 2025: Blurring the Specification

In Fall 2025 we tried a partial fix: blur the specification, so students would have less to hand to AI. Start with an ordinary assignment, a linked list with insert, delete, reverse, and toString.

Replace the words with emoji.

Then blur some of what is left. It does not work. Increasingly capable agents completed blurred specifications anyway, and students still passed the spec to AI.

Slide 10: Fall 2025: A Failed Experiment

So, honestly: the Fall 2025 redesign failed. These are students describing what they actually did. The project is too difficult to do by yourself, yet too easy to do with Claude. You can just ask Claude to do everything for you. The information students need to fairly complete an assignment is enough information for AI to complete it too. The failure was useful: it told us what not to design.

Slide 11: Spring 2026: An Independent Project

So in Spring 2026 we started somewhere else: with the student.

Every one of about four hundred CS 124 students started from their own idea, from paired brainstorming and peer feedback.

They worked through that idea in collaboration with Claude Code, writing their plan in conversation before building. The hard part of working with a coding agent is not generating code; it is getting the idea out of your head into a specification the agent can follow, and the course scaffolds that work.

What comes back to me is an app, a different one from every student. No two are the same, and that is the point.

Slide 12: Time on Task Grading

Because no two projects are the same, we cannot grade against a specification. So we grade time on task.

Students collaborate with AI, the session logs are captured, and from them we estimate time on task: here, about twenty hours over five weeks. AI itself distinguishes substantive engagement from off-task chatter. The estimate is shown back to the student.

This is the student's dashboard, week by week. AI makes completion trivial, so engagement becomes the real signal.

Slide 13: What They Built

Here is what they built, a few of the best from this spring. A simplified launcher for seniors, with medication reminders and a kiosk mode. A lab assistant that schedules and tracks multi-day materials-science experiments. A quote-sharing app with emotion tagging and a 3D sphere visualization. Domains we never would have specified.

Slide 14: Teaching Classical Programming

Let me be clear about what this is not. I am not abolishing fundamentals. Classical programming still matters, for the people who will work at that layer, and we still teach it, with interactive practice like this one on learncs.online. Project work is not the whole story: we still measure the classical skills, for real.

Slide 15: Frequent Small Assessment

The shape we want is many small assessments instead of a few big ones. Instead of a midterm and a final, four proctored hours of high stakes, students take fifteen weekly quizzes, fifteen hours of proctored testing per semester. Each one is cheap to take, cheap to grade, and gives fast feedback.

Retake windows run all semester, so one bad week is not final.

And we drop the low scores: the best twelve of fifteen count.

Slide 16: Institutional Support

None of this works without institutional infrastructure. The Computer-Based Testing Facility at Illinois is that infrastructure: secure, proctored, frequent, at scale. This is huge. The bottleneck on better assessment is rarely the idea; it is having the facility to run it for real, at scale, securely. The future of assessment is here, not in Canvas.

Courses

Slide 17: Courses

The second section is courses. Its anchor is Seymour Papert, quoted by Alan Kay in 1972: should the computer program the kid, or should the kid program the computer? One design philosophy runs through it: AI removes barriers to substantive, personalized, well-structured learning for every student. This work is in collaboration with colleagues at Illinois, UBC, Replit, GitHub, and Optimizely.

Slide 18: Built Through Conversational Programming

First, a course that has already run. This spring I launched Using and Understanding AI, a course on generative AI for non-technical students: no prerequisites, no code. Its site was built entirely through conversational programming. I did not manually read, write, or debug a single line of the code that powers it, across 199 sessions, 68 days, 4,038 turns, and 29,770 tool calls. Every feature was built by describing it to Claude in plain language.

Slide 19: Conversational Assessment

The piece I am most excited about pedagogically is conversational assessment. Here a student is assessed on the Turing test through a natural conversation with an AI.

Slide 20: Oral Assessment at Scale

This connects to Paolo's talk this morning. The oral exam is a gold standard: you cannot fake understanding in a real conversation. An interviewer agent talks with the student, while an evaluator agent silently scores the transcript against the rubric. We validated it against adversarial personas, and the hardest to defeat was the confident bullshitter.

The oral exam just never scaled. Now it does: the same conversation, for every student, in the testing facility. Scalable, high-frequency, and auditable. The same conversation that builds the software can measure what the student understands.

Slide 21: What They Built

And here is what students who never wrote code built for their final projects. An aquascaper built Tank Hub, a tracker for tanks, livestock, plants, water chemistry, and maintenance. Another student built a full sorority platform that replaced apps her sorority pays for: admin controls, member dashboards, dues, points, calendars, meal sign-ups.

Slide 22: My Hypothesis

That brings me to the hypothesis underneath all of this.

The prevailing view treats programming and AI collaboration as stacked: learn classical programming first, and then you can build with AI.

I suspect they are independent, but related. AI collaboration is a distinct skill, independent from, but related to, classical programming. In both CS 124 and Using and Understanding AI, most of the value came from decomposing the problem, directing the AI, and judging its output, not from reading or writing code. The honest caveat: every foundations-first result was measured on students taught code first. No one has run the other arm yet, and I want to.

Slide 23: “Conversational Programmers”—Not a New Idea

Which leads to my next course, and the idea behind it is not new. Conversational programmers are Parmit Chilana's work from 2015 and 2016, championed by Mark Guzdial and Katie Cunningham, and Hur and Cunningham found at ICER 2024 that it is the single most popular endpoint for non-CS majors who take a computing course. Then, students learned enough programming to talk to coders. Now they direct coding agents, and own the intent, the specification, and the verification. Same instinct; the partner changed from a person to a machine.

Slide 24: Closing Software’s Oldest Split

Here is the deeper point. For decades, the person who cared about a problem, the domain expert who knows what is right, and the person who could change the artifact, the developer, were two different people, joined by a lossy requirements channel. Most of our security and usability failures live in that gap: not negligence, a broken channel.

Agents collapse that split, and that is plausibly the main thing they fix. One person, directing an agent: the person who cares can finally change the thing. Evaluation was always the domain expert's job; it was just stranded on the wrong side of the wall.

Slide 25: The Trust Gradient

So the course is organized around a trust gradient, from how to make something true, which is the agent's, to what should be true here, which is yours. At one end, syntax, scaffolding, secrets, and input sanitization: the agent is boringly reliable, so learn to verify, not babysit. In the middle are the traps, green checks that lie: one hundred percent coverage of the code it wrote, accessibility a real user still cannot navigate. At the far end, the threat model, the user model, and what is worth building are yours to own. The skill is epistemic discipline, a phrase I borrow from Paolo this morning, and we grade the delta: what the student adds past what the agent raised.

Slide 26: A Studio, Not a Lecture Hall

And we run it like an architecture studio, not a lecture hall: one artifact, many crits, each pass foregrounding a different concern. One project all term invites over-design, because without a real user nothing forces the scope. So students build a portfolio of small, disposable projects first: build, demo, delete. Then they converge on one user-anchored final project. The return is subtractive: a real user model usually says you do not need seventy percent of what you built. The end is where the project gets right, which means smaller.

Slide 27: Fall 2026: Conversational Programming

That course is Conversational Programming, launching this fall at Illinois, built around conversation as the programming interface. If you can talk it, you can create it. As Paolo put it this morning, the conversation is the computer, and this is what that looks like as a course students actually take. It is also the seed of something bigger than a course.

Degrees

Slide 28: Degrees

The third section is degrees. Its anchor is Douglas Engelbart in 1962: augmenting human intellect, increasing a person's capability to approach a complex problem, gain comprehension, and derive solutions. What you just saw is one course run like a studio. Applied Computing is that studio model as a whole degree, scaled up from a class to four years.

Slide 29: Two Computing Populations

Two populations of computing students have come into focus. These quotes are from faculty in our Future of Computing conversations at Illinois. Some students are fascinated: they want to know everything about everything for the sake of knowing. Others are driven: they have a vision, and are interested in everything that will help with it and nothing that will not.

Computing as ends, which Computer Science already serves well, and computing as means, which no degree serves yet. These are not categories but dimensions, and most students mix the two.

Slide 30: Applied Computing

Applied Computing is a draft undergraduate degree for that second population, inspired by architecture: explore, design, prototype, critique, iterate, validate. The goal is graduates who use AI to build software that serves real people in specific domains, and who produce good work, not just working code. Architecture is the original union of art and science. As AI absorbs the mechanical production of code, what is left for people is exactly what it cannot supply: taste, design, responsibility.

Slide 31: The New Core

This is the new core, six courses across the first two years: the technical identity of the degree.

Conversational Programming: designing and building software through conversation with AI, a studio in spirit before the formal studios begin.

Computing in Culture: how software has reshaped human behavior, a critical lens that runs in parallel with learning to build.

Agentic Software Development: constructing and evaluating agents, agentic workflows, and real deployments. Students learn to be effective directors of AI.

AI Models and Agents: how models actually work, placed after fluency, so students step back to reason about systems they have already built with.

Integrative Design Studio I: students bring a paired domain problem into the studio and design software around it, with architecture-style critique.

And How Software Works, the classical programming course: what happens beneath the conversational layer, and a bridge into upper-division CS electives. It comes last, not first. Fluency first, then the move backward to the systems underneath. That ordering is the hypothesis made concrete.

Slide 32: Design Pillars

Beyond the core, three pillars. A domain concentration through any existing minor on campus: the domain tells you what to build. Formation through writing, literature, moral reasoning, and studio art, because students who build for people need to communicate, reason ethically, and see clearly. And a studio progression run as a portfolio model, three studios and then a capstone with a public defense. Students graduate with a body of work, not a transcript. All of it is borrowed from architectural pedagogy, tested for centuries.

Slide 33: applied-computing-close

Stewart Brand, 1968: we are as gods, and might as well get good at it.

In 2009 he changed the verb: we are as gods, and have to get good at it.

Slide 34: History Rhymes

History rhymes. Let me end where computing began.

Grace Hopper wanted data processors to write their programs in English. J.C.R. Licklider imagined computers devising their own procedures for achieving stated goals. John Kemeny envisaged millions of people writing their own programs. Edsger Dijkstra and Joseph Weizenbaum sounded the cautions. 1958 to 1976. The dreams are seventy years old, and for the first time they look deliverable.

Slide 35: Closing Thoughts

Four closing thoughts. Change our work, and ourselves: new assessments, new courses, new 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, we do not yet know how to teach it, and 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.

Slide 36: Thank You

Thank you to David Rosenblum for the invitation, to Giancarlo Succi and the School of Computer Science and Engineering, to co-chair Jürgen Schönwälder and organizer Stella Byun, and to everyone in Bremen and online. Join our online community for computing educators at computingeducators.org. I am excited to keep building this together, happy to take questions, and glad to keep the conversation going by email.