The New Computing
AbstractAbstract
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 ~25-minute talk opens Day 0 of the GitHub Education Educator Summit 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.
SummarySummary
The opening talk for the GitHub Education Educator Summit’s Day 0 Changing Curriculum workshop, in person at GitHub HQ. It argues that AI’s emergence forces computing educators to redesign what we teach, and 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; Using and Understanding AI, a new course for non-technical students built entirely through conversational programming and anchored by multi-agent conversational assessment; 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 open question it raises for the rest of the summit: what is the right balance between classical fundamentals and agentic development, and what specifically makes someone a good AI collaborator?
History rhymesHistory rhymes
The opening reads five quotes from computing pioneers without attribution. They sound like they could have been said yesterday. They weren’t. Grace Hopper on programming in plain language. Joseph Weizenbaum on what we don’t know how to give machines. J.C.R. Licklider on translating natural-language goals into procedures. Edsger Dijkstra on a high-level language mutilating the minds of students learning to program. John Kemeny on millions of people writing their own software. 1955 to 1975.
The hope-and-fear cycle is older than the technology. We have been here before, every time computing has moved closer to ordinary people—compilers, BASIC, the personal computer, the web. Every time, we worked through the uncertain middle. We will this time too. The rest of the talk is a few first steps I’ve taken—not predictions about how it ends, but moves I can show you.
Assessments: CS 124 in Spring 2026Assessments: CS 124 in Spring 2026
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.
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, we went back to the drawing board.
In Spring 2026, 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: the first half is design, ideation, peer feedback, and brainstorming feasibility with Claude; the second half is structured building sessions. 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: 15 hours of proctored testing per semester in the Illinois computer-based testing facility, mastery learning, and frequent small assessment with rolling retakes. The pre-AI pedagogy that worked still works.
Courses: Using and Understanding AICourses: Using and Understanding AI
This semester I launched a new course on generative AI for non-technical students, designed as a general-education entry point into AI literacy—no prerequisites, no code. The experiment isn’t only what to teach; it’s how many places in the course’s content, infrastructure, and operations I could let AI in.
The course 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. Inductive sessions use interactive artifacts students play with before we name the mechanism; AI-supported preparation means human-to-human conversation in the room starts on common ground; and the piece I am most excited about pedagogically is conversational assessment—the chat-based equivalent of an oral exam, scaled. A multi-agent system: an interviewer agent talks with the student, an evaluator agent watches the rubric. We validated it against adversarial personas; the hardest to defeat was the confident bullshitter. The same recipe collapses any slow human feedback loop into many fast ones.
Several students kept building beyond the course. One built a full-stack replacement for the apps her sorority pays for; another, an aquascaper, built a tool for tracking tanks, livestock, plants, water chemistry, and maintenance—a domain I had never heard of before this semester. With Cory Gwin at GitHub I am planning a Fall 2026 pilot of Conversational Programming, a course for non-technical students with no code to read or debug.
My hypothesisMy 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. If that’s right, we shouldn’t gate agentic work behind a year of programming; we should at least try teaching it first. 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 ComputingDegrees: Applied Computing
Through faculty discussions at Illinois about how our programs should change, two populations have come into focus. Some students 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 proposal for an undergraduate degree built for the second population. The core leans on conversational programming first, classical programming later—six courses across the first two years, ordered deliberately: 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 with a public capstone defense. Much of this is borrowed from architectural pedagogy—students build, critique, iterate, and validate, repeatedly, in front of peers and the public.
The section closes on Stewart Brand. In 1968, Whole Earth Catalog: “we are as gods, we might as well get good at it.” In 2009, he updated the verb: “have to get good at it.” We are handing students tools more powerful than anything Brand had in mind—and we have a particular responsibility for what they build.
What’s nextWhat’s next
The talk hands off to the afternoon’s Changing Curriculum workshop and to the Day 2 Curriculum Overhaul session—co-presented with Cory Gwin and Leo Porter—which take up the open question it leaves on the table: the right balance between classical fundamentals and agentic development, and what makes someone a good AI collaborator. Thanks to Cory and Morgan at GitHub Education for hosting, and to Leo Porter for facilitating.