Computing Education in Human Language
Watch
AbstractAbstract
Computing in human language is a dream as old as computing. Today it’s coming true all around us. Good coding agents are barely a year old, and already people with no technical training are using them to create technology. We haven’t even started teaching people how to do this yet!
This fall I launched a new course on conversational programming, with no prerequisites, in which students build websites, tools, games, and analyses with an AI coding agent, all without ever interacting with code or most computing concepts. It’s a studio, not a lecture: students spend each session building, observing, and critiquing, and every conversation runs through our courseware, turning the agent itself into a personalized pedagogical agent that helps students learn as they build. I’ll share what we’ve learned so far: our eight principles for AI collaboration, the human challenges inherent to it, how little students seem to need to know before they start building, and why we should introduce AI early in our computing programs.
But the most exciting students in this story may be us. I’ll close with what educators are already building for their own courses, and how that’s spreading at Illinois to colleagues outside computing through Educators Who Build meetups. I’ll also advocate for better institutional support for instructors who are creating novel pedagogical technologies. Now that everyone can build, we need far better ways for educators to deploy their ideas.
Slides
You just did it
Thank you, Cory, and thank you all for the day. It has been inspiring to watch computing educators engage with these tools and see what is possible. You just spent a day in a studio. I have been running one since September, with about twenty students who have never written code and never will in this class. Twenty minutes, and then your own ideas.
Two dreams coming true at once
I have been thinking about why this moment feels the way it does, and I think it is because two dreams are coming true at once, and computing educators stand where they overlap. The first dream is computing's own.
Grace Hopper's team wrote this in 1958 about FLOW-MATIC: anyone can use this system with little training, and detailed computer coding is no longer necessary. In our language, not the machine's. This field has wanted that since the beginning, even when it forgot. It saddens me that she is not here to see it.
This is a campus, the whole of it, as it was. Communicating with a computer in its language is difficult, and if you think about it, dehumanizing.
The people in this room are the survivors, the ones who were good enough at it or liked it enough to keep going. We lost so many people to the fact that programming is not just hard but unpleasant, people with real dreams about what they wanted to do with computing. One in ten stayed. Now we can bring the rest back.
That is the computing dream. The other dream belongs to educators.
Patrick Suppes, in Scientific American in 1966: in a few more years, millions of schoolchildren will have what Alexander had as a royal prerogative, the personal services of a tutor as well-informed and responsive as Aristotle. Sixty years of waiting, because nobody could afford it. With agents, we can build it.
Where the two circles overlap is this room: computing educators. The computing dream shapes what we teach. The educational dream shapes how we teach. And we share both with our colleagues. The rest of the talk is those two words, what and how.
Conversational Programming, the course
This fall at Illinois I am teaching a new class, Conversational Programming. No prerequisites, and we never read, write, or interact with code. Students use Codex on their own laptops, every request through our proxy, and realize what they want by talking to an agent. It is complementary to the studio courses for majors, like the one Cory ran today: those are urgent, and this course is the other opportunity, to re-invite everyone we pushed out.
Three projects. The first is your own website, live by week three.
The second is something for a classmate, built from the classmate's own idea: she leans in and describes it, and he and his agent build it.
The third is one idea the whole room chooses, prototyped many ways, like an atelier gathered around a single model.
Here is what changed about iteration. One semester, the old way: a single pass through design, prototype, build and evaluate, and almost all of it is building. The old software studio spent a semester barely getting one thing to work.
With an agent, the build collapses into days.
So the freed semester fills with more passes, five of them, and the time goes to design and evaluation: is it good, does it solve a problem, what is another user's experience, how do you handle conflicting criticism. I once asked my senior majors how many had ever used something a classmate built; they looked at me as if I had four heads. These students did it in half a semester.
What we teach
What we teach is a skill barely a year old. This chart is people over time, on a log scale, and it starts empty.
The first line is people using a chatbot on the web, the free tier and the weaker models: nearly a billion a week now.
The second is people working with a frontier coding agent. I date the good ones to Opus 4.5, last November, the dashed line along the bottom. On a log scale the agents line looks respectable.
On a linear scale it is squashed onto the axis where it belongs: nearly a billion people a week on a free chatbot, a few million with a frontier coding agent. Your students are up on that line; this room is on the floor. Karpathy drew it as a funnel, and the gap is our job. Nobody knows how to teach this yet, me included. We had decades to build the curriculum from variables to conditionals; nothing like it exists here. The course exists to find out, and it collects data as it goes.
Where the course's principles come from, honestly: my own practice. Every square is a day in the last year, shaded by how many prompts I sent a coding agent. Almost forty-seven thousand prompts, eighteen hundred sessions, three hundred and sixty-nine days. The busiest day was seven hundred and ninety.
And what is running right now, this fall. Nine websites, the course site above all. Ten projects: talks, studies of our own teaching, a working group. Seven pieces of software, from the servers the course runs on to the tools my agent uses. I have been code free for a year. I build technology in natural language.
And then August 30. After all of that, I finally asked.
At eight on a Saturday night, in a working session on my CS 124 transcripts, I typed this: I want to teach students to communicate with you effectively. How do I do that?
It answered with nine things. The conversation is set before the first prompt. Tell it what you saw, not what you concluded. Never accept done without looking. Give outcomes and constraints, and let it own the steps. Correct it, out loud, early. Ask for explanations before failure, not after. Keep it oriented. Calibrate the hand-off. Ask the agent how to work with it.
Take away the glosses and the list is what remains.
My reply: I am kind of embarrassed to say I have never asked you that question. I used you for over a year before we had this conversation.
And so I came down from the mountain with the tablets.
Thou shalt say what done looketh like, and not the way thereto. Eight commandments, in the language of tablets. Every student in the course has since asked their own agent the same question, and the answers were remarkably consistent. The one I will say: ideas, not implementation. The agent knows everything about technology and nothing about the student's life; the student brings the opposite. These tools are capable and compliant: treat one like an intern and it behaves like one. Say what you want to happen and let it work out how. Working things, deployed, in week three, with no computing concepts at all.
Never accept done without looking. The agent says it is done and the tests pass; how would you know? Last Friday that was the whole class: twenty minutes alone with their agents, no list. Two hundred and sixty-one ideas, most of them out of the conversation with the agent, and exactly one said read the code. Nobody should read the code. That is a terrible way to check. The agents do the looking.
This is agentic validation. An agent uses it like a person would, driving the browser through every screen. An agent tries to break it: blank fields, a reload halfway, two accounts, a dead network. An agent checks the facts, and agents check each other: a second one hunting for claims the first can't support, tests that run after every change.
How we teach
How we teach, we borrowed from architecture and design studios. Not a lecture. Students talk to each other, present work for critique, and watch each other work with their agents. The studio is a structure: the same ninety minutes across, and three lanes, the whole room, pairs, and independent work.
A different shape every week. Fresh Eyes: four partners in a row. Built for Us: rounds the clock runs, then the whole room votes. How Would You Know: independent, then together, then independent. Ready: try it, build on it, try it again.
Thirteen class days so far, and every one is a mix: studio time building, desk crits in pairs, and the pin-up, where the whole room critiques. Each card's bar is that day's minutes by mode. Every day is an activity, and every activity is a plan file anyone can run.
This is a class in motion, four screens in step: one student talking to the agent, the partner watching the live feed and keeping notes that stay hidden until the end, and the room page that runs the plan. Fake personas replaying the real stack. The old software studio spent a semester barely getting one thing to work. Now the building collapses into weeks, and the time goes to the questions that matter: is it good, does it solve a problem, what is another user's experience, how do you handle conflicting criticism. Sit in the room and listen, and that is what the students talk about. The course site that runs all of this was built by conversation too.
Learning agents
The second dream, as built. Students work through AI endpoints the course provides, and because everything flows through us, I do not just see it, I shape it. From the student's side there is one agent.
Behind it, two. One builds. The other, the learning agent, watches the conversation for the moment to step in, and answers in the builder's voice. What it is told is context, never instruction: this student is working on interface design this week, never don't write the interface.
Pull back and every table is a three: a student, a builder, a watcher.
The whole room: human helpers and their agents between the tables, and me at the side desk beside my own agent, pointing out where help is needed. The agentic classroom.
One step-in, a real one. The agent had said fixed, with three hundred and sixty-two tests passing, and the student was moving on to a new feature.
The learning agent asked, in the builder's own voice: before I switch APIs, what did you see when you opened the app and tried the break?
The answer: after I clicked, the window still disappeared.
So it fixes that first. A TA beside every student, in real time, and I configure it in paragraphs. Students answer this question about seven times in ten once it speaks in the agent's own voice.
What does it cost? Seven hundred and thirteen dollars, for nineteen students' coding agents from September 1 to today, thirty-six thousand requests, estimated at the vendors' list prices. That is about thirty-seven dollars a student, roughly two months of one twenty-dollar AI subscription, except that no student holds an account: the course holds the key, pays, and watches. The watcher that rates every turn cost thirty-five cents. The university pays through its central AI service, students pay nothing, and a daily cap bounds the tail: past fifteen dollars a day a student gets a cheaper model, and no student has cost more than about sixteen fifty in a day.
By week, the climb is October: students building, on the strongest model, about thirteen dollars a student a week. The hosting runs on infrastructure we already had.
CS 124 is the version anyone here can do this week. A thousand students, each building a project with an agent, classical programming still assessed. Every CS1 student should start AI collaboration now. The lesson on these principles is a prompt on a page.
They paste it into their own agent, which runs the tutorial against their own project and their own prompt history.
Here is a prompt of yours that said what. Here is one that told me how. Let's rewrite the second one together. A tutorial inside their own agent, personalized, with no infrastructure at all.
Elizabeth Holmes promised that you could see everything. This time it is true. The agent does all of the implementation, so to get what they want the students have to say it, and every word of the saying runs through us and is recorded.
One afternoon, October 21. Every student is a line. Every request their agent made is a cell, brighter for more.
Every message they typed is a tick. Every time the TA stepped in is a diamond. The pairs form and re-form across the afternoon. Process evidence at a scale and resolution we have never had.
What is in her head leaves it as words, and the agent beside her builds from the words. Nothing else crosses the table, so all of it can be kept.
The conversational classroom
I build the course as I go: in class I watch, take notes, and tell the agent what is working and what is not. Then it dawned on me that this is how I will teach in the room too, through chat, as the coordinator of a team of learning agents. On October 23 I ran seventy-five minutes for nineteen students almost entirely from this window: thirty-three messages from me, twenty-six room actions. Here it reads the ideas board and the room and proposes when to call the next stage.
Here it finds a student whose agent has been quiet for a week and pages them to come talk to me.
Here it moves the class to the next section, restarts the music, and extends the build to the end of class. It tells me someone needs help over here, that two students are stuck on the same thing, that the activity I said would take ten minutes has taken eleven. I have one classroom and my own limited imagination. You have ideas. Try them.
Build it, and share it
Two responsibilities at the intersection of these dreams. To our students: teach them to collaborate with AI, in studios like today's. That means using the tools ourselves, with frontier models pushed as hard as they go, because there is no pedagogy to receive; the only way to learn to teach this is to do it. Twenty years of code by hand is not a moat; I wish it were. To our colleagues: last summer's AI Studio at Illinois put thirty-four instructors from twenty-three departments, with no technical background required, to work for five weeks building useful things for their students. This is what colleagues build when building is cheap.
Credit Cory for the push to work with other educators. Educators Who Build is a site for organizing local meetups of the people doing things with AI, not just talking about it. A site per campus; the next Illinois session is November 2. Ask for yours at educatorswhobuild.org.
And the course is open. Every activity has a film and a Running It Yourself section, and every session is a plan file: conversationalprogramming.org/educators.
Computing educators and this moment
Danny Hillis, in the Atlantic this spring: tech without the tech companies. That is what this room can make true.
For the whole history of computing, a few people built the technology everyone else lived with. I do not like how Facebook works, but I do not work there, so I do not get to change it.
That is ending. Everyone can build for a few, or for themselves: educators building tools for their own classrooms and their colleagues, not waiting on a company miles away. Nobody has to stay stuck inside technology someone else made for them. Computing educators decide what this moment becomes. We reach more people than any product, one course at a time, and it multiplies through our colleagues in every other field.
The campus again, and this time its agents are in the picture.
Two dreams, seventy and forty years old, came true in one room this fall. I look forward to meeting you all in this future.
