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. And 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 is a studio, not a lecture: students spend each session building, observing, and critiquing. 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 I think we should introduce AI early in our computing programs.
Then I want to talk about what instructors need to teach this skill. Almost none of it exists yet, but Replit is perfectly positioned to provide this learning environment. Teaching conversational programming means seeing the conversation, not just the output; configuring what the agent knows about each student and each session; managing a room of students each working independently with their own agent; and assessing work that no two students did the same way. I’m building this myself this semester through AI collaboration, but other educators will want a platform. I’ll bring feature suggestions informed by my early work in this space, in hopes that, together, we can teach the next billion technology creators.
Slides
Why I am here
Thank you to Brandon Middleton, who leads education at Replit, for bringing me in, and thank you all for having me. I was at GitHub yesterday, I had today free, and instead of walking by the ocean I got up early and trekked out here, because I want your help. Since September I have been running a studio of about twenty students who have never written code and never will in this class. Thirty minutes, then let's talk.
Two dreams coming true at once
Two dreams are coming true at once, and I 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. 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.
Programmers are the survivors, the ones who got through. We lost most people to the fact that programming is not just hard but unpleasant. One in ten stayed. Those people are your users now, and we can bring them 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 where I stand: computing educators. The computing dream shapes what we teach. The educational dream shapes how we teach. The rest of the talk is those two words, and then what a platform would need to serve both.
The printing press
Agents are a printing press: the cost of making software has collapsed, the way the cost of making a book did around 1450. But the press did not make readers. Here is how long reading took.
The world: three and a half centuries later, in 1820, twelve percent could read, and past half only around 1965. Five centuries from the press to half the world reading, and the press was not what was missing. A reason to read and schools were. One book I have been reading traces the reason to the Reformation, the first time people were told to read for themselves rather than trust the people who could. I sometimes call where we are now the software priesthood: a small number of people build the technology that everybody else is forced to use.
Our press arrived last year. Your next billion software creators will not find the tool on their own. They are going to be taught. Five centuries or a decade: the teachers decide.
Which is why I am here. I think Replit is ninety-five percent of the way to the most important computing education platform ever built. From above, the bridge to the future, with the lanes queued at one missing section. This fall I built the last five percent by hand, for one course, because nothing like it existed. Everything in it is something a platform could offer every educator. That is the ask at the end. The evidence first.
Conversational Programming, the course
Illinois, this fall: Conversational Programming. No prerequisites, nineteen students who had never written code and never will in this class. We never read, write, or interact with code. Students talk to a coding agent and realize what they want that way. The humans do the human part; the machine does the machine part.
Three projects in one semester, which for people who had never programmed is itself remarkable. The first is your own website, live by week three. About half of those sites all looked the same, unmistakably AI, and the other half were really interesting. I am still working out why, and I do not think it was just effort. Some of them may never have seen what a website can be. So we had them find personal websites and rank them head to head, by Elo, and the top ten were wild. Next time that exercise comes first.
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.
The stack, because this room will ask. Codex on the students' own laptops, talking to the agents, and every one of those conversations passes through one point: our proxy. That is where I sit, watching and taking notes. No IDE, nothing hosted for them, on purpose: the environment the course needed was not a code editor. It was the conversation. It has cost about seven hundred dollars so far for nineteen students, and the university pays.
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 users are up on that line; this room is on the floor. Karpathy drew it as a funnel, and closing the gap is the job. And nobody knows how to teach it 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. It is also why educators cannot sit this out. Once a field matures it has a received pedagogy: you can learn to teach math without being able to do all of the math. This has none yet, so right now the only way to learn to teach it is to do it.
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. Their competence is matched by their compliance. This month I noticed I had been deploying my own website in a really dumb way for months, five minutes a time, with an agent beside me the whole way. It could have been five seconds, and it never said so. I suspect people from computing have it worst: we took a data structures course once, so we say use a hash here, to something that knows every data structure and could invent a new 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 third tablet, and the one this room should care about most. The agent says it is done and the tests pass; how would you know? Last Friday that was the whole class: the students 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, which your agent already does to test its own work. 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, screenshots kept as evidence rather than a verdict. The skill we teach is asking for the evidence and looking at it, not trusting the green check.
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. And it is live: class meets Wednesdays and Fridays, and on those mornings I go downstairs and start prompting, and the class emerges, hopefully by 12:30.
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. A session is a plan, not a script; nothing advances on a timer, I press Next. The transcript is the artifact, and we critique the conversation, not the code. The course site that runs all of this was built by conversation too.
Learning agents
The second dream, as built. Every request flows through our proxy, so I do not just see the conversation, 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. Every note a student's agent received is published to that student, word for word.
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. A hundred and ten step-ins reached all nineteen students in four days.
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. Today it can only speak through the other agent; your integrated environment could do better.
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. The median message went from twelve words in September to twenty-two in October; the messages got longer, because the activities asked for it. Process evidence at a scale and resolution nobody has had, and today no product shows an instructor the conversation.
What is in her head leaves it as words, and the agent beside her builds from the words. You cannot point at an agent and make a face; as I tell my students, use your 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. And that is what all this observing is for: sending the humans where they matter. To some degree the conversations show a student's state of mind: frustrated, excited, stuck. That is the moment for the agent to tap me on the shoulder, not so I can show the student anything, just so I can be there with them. Visibility nobody has ever had; my job is the energy in the room. One thing holds it back: agents only answer. Nothing in the background can speak first, and what I want is to walk the room and have my phone buzz. I am building that in the browser, because a browser-based chat can be written to. Yours already is. Every agent product today assumes one person and one project. A classroom is a room, and nothing in the products knows it.
What Replit has, and what is missing
Let me say the awkward part out loud. In 2023, computing teachers built whole courses on Teams for Education, and when it went away they scrambled. What they missed was not the editor; it was being able to see how a student got there. And I understand the other side: it was losing money, and the education market, as one article put it, turned out to be small.
But that was a market of computing teachers teaching programming. There is a completely different set of educators now: people teaching students who will never write code to build technology, in every discipline. I expect computing to become a service department, the term of art for one that teaches far more students from outside its program than inside. Math is the classic case. Computing today is the opposite, and I think the number of majors is going to collapse; it has already started. We will have to teach this to everybody, and many of the people teaching it will not come from computing, because computer scientists refuse or because they are not the best people to do it. Last summer thirty-four instructors from twenty-three departments at Illinois built things for their own students. They have no IDE to defend and nothing to migrate. That market is not small. It is everyone.
So, the brief. You have most of it: Agent 4 builds whole applications for people who have never coded, with deployment, auth and data behind it; fifty million users; Free Mode since August; a phone in every pocket; and the education footprint is back. Chat beside the website is exactly the interface I want. Everything I just showed you I built by hand around a coding agent on a laptop. What those teachers missed, seeing how a student got there, is the piece I am asking you to build, and now there is a conversation to see, not just keystrokes. Four needs ran through what I built, and each one is a seam.
See the conversation. Today students manually share individual chats, and no software can follow along.
Affect the conversation: the course, and its learning agent, shaping it while the student works. Today there are only static instructions for the entire workspace.
Manage a studio classroom. Today everything lives one project at a time.
Assess the process. Today there is only the finished work. Here is what each could look like; these are mock-ups we drew, not features.
The conversation, live, shared under the course's consent instead of chat by chat. Watched as it happens by the partner and by me, with notes pinned to a turn: she moved on without opening the preview. And the same stream open to software, so a learning agent can read it, not only a person in the same workspace. The K-12 tutors already let a teacher see the conversation; no coding agent does. This seam matters most, and it needs the learner's consent built in.
The course as a setting. A semester note, today's session that I change mid-class and that applies on the next turn, a note per student that the student can see, and step-in rules: a hook on a turn. That is a paragraph of configuration for an instructor; today it is a proxy and a server.
And what it produces: the step-in, in the agent's own voice. Try it; what did you see? The student sees one agent; staff see the rule that fired. Game-changing pedagogy, and totally possible.
The room. Every student's project on one page with its state: building, stuck nine minutes, done but unverified, silent for a week. A room agent I can ask who needs me right now. And the activities as buttons across the room. Today there is no roster, no view across nineteen projects, and a Pro workspace seats fifteen. Give educators these taps and they will build their own classroom tools on top, which is the right way, because everyone runs a room differently.
The process. One student's project reviewed from its conversation: what she typed, what she accepted unread, where the step-ins landed, a rubric for the process that a review agent drafts, and a done that gets re-run in a clean preview before anyone believes it. In CS 124 today I estimate the time students spend and grade that, for lack of anything better. If you wanted to start running and I knew nothing about you, I would say go run for twenty minutes: an honest proxy, and we need to go deeper. And nobody has to stand over them. When I walk up to a student, they suddenly cannot type. Send them home and read the conversation tomorrow. Your educators page still promises groups, assignments and submission review; I would like to help you make that sentence true. And one commitment that rebuilds trust with teachers: course data outlives the plan, with export. Let a teacher doubt done: the process is the record, not the green check.
Exercises only a platform that owns both the code and the conversation can run.
Hot-potato prompting: one student works the project for five minutes, then hands it to the next.
Same start, how far: two students begin from the same place and see where each gets.
Fix the bug, how fast: the same broken project, on the clock. You own the code and the conversation, so you can do these better than I ever could.
The barge is moored in the strait with the boom toward the gap. I do not work here; I half wish you would hire me as an intern for a semester to knock these out. A couple of wires pulled a little closer, and the lanes flow east. One instructor running a studio of nineteen agents with no engineering staff: I did it by hand. It should be a product, and nobody else is positioned to build it.
Coming home
The campus again, and this time its agents are in the picture. We have lived through a past of people building things for other people without understanding their problems: social networks built by people who do not understand friendship, educational tools built by people who do not understand education. I am the expert on my own problems.
Two dreams, seventy and forty years old, came true in one room this fall. The next billion technology creators are out there, waiting to be taught. I look forward to meeting you all in this future.
