For Educators

The World Is Changing

The ability to build software, for seventy years concentrated in the small group of people who could write code, is being handed to everyone. Anyone with a vision can now realize it. This is what computing education always said it wanted: democratization, access, everyone building. It's here.

So we get to decide what comes next. What do students need to learn when the machine handles the syntax? What new skills matter? What does it look like to teach someone to build through conversation? These are open questions, and nobody has answered them yet, including us.

What We're Trying

Conversational Programming is a first course with no prerequisites, running at Illinois in Fall 2026 as CS 199 ASK and again in Spring 2027 as CS 199 CP. Students build real software, websites, tools, games, and analyses, by working with an AI coding agent, and they never read or write a line of code. It's a studio: most of the time is spent building, the rest looking at each other's work, and students watch each other work with the agent as much as they critique what comes out. There are no lectures. Grading is participation.

The honest premise is that nobody knows how to teach this skill yet. Most courses that try start with the computer science we used to have to teach first. We start with nothing and let the students, the agent, and the work tell us what actually needs to be learned. The course is the experiment. The syllabus says all of this in more detail, and it will change as the semester teaches us things.

AI has what researchers call jagged intelligence: brilliant at some tasks, surprisingly weak at others, with edges that move as the technology does. Our students will find those edges, and so will we. Part of teaching this is learning to recognize where the agent struggles and helping students work around it. That's the frontier, and we're exploring it together.

What We've Done So Far

Five sessions in, as of September 16, this is what a class has looked like. The first activity was solo: install Codex, paste one line, and start a personal website, the portfolio everything else this semester will hang from. Setup took some people the whole period and others no time at all, which was about laptops, not students.

The second was pair prompting. One student builds while a partner watches how they ask, not whether the site is any good, and says what they see in three shapes: I notice, I wonder, what if. Then they swap. The partner follows the conversation on their own screen, a few seconds behind, and the notes they keep go to the person they're about after class, not during. The third was Fresh Eyes, the same three shapes turned on the work instead of the process: a partner looks at your site the way a stranger would and you change it while they watch, on your own laptop, eight minutes each way, and then everyone finds someone they haven't worked with yet. The premise is that a change now costs a sentence, and so does undoing it, so the slow part is knowing which change to make, and feedback is worth more than it has ever been.

The fourth, Going Live, put every site on the internet, and it was the first day the course's server did anything besides record. Pairs stayed together for the whole period, both building. At the end of every request a student's coding agent made, the server added a short note: the day's task and what a good host looks like, the suggestion to buy a domain, and a link where the agent could report the site's address once it loaded, which the course then checked from outside. And a few times an hour, only when something had happened, a line about what the student's partner had just done, which the coding agent passed on in the course TA's voice: "Priya's site just went online; ask her for the address." The student's answer went back through the same channel, and the course compared it with what the partner's agent had actually done. Every note is on the activity page, word for word, because the students are learning to set context for an agent and this is ours.

The fifth, Show and Tell, is the first whole-room critique, and it runs over two days so that everyone gets seven minutes. Until now the person looking at a student's site has been sitting beside them, close enough to be told what it was meant to do. The room can't be told: eighteen people open the address at once and see what is actually there. Nobody plugs into the projector either. The presenter's page captures their whole screen in the browser: the projector shows it as live video when the room's network lets the two machines reach each other, directly or through a relay we run, and as stills a few times a second when it doesn't, while everyone else's page gets a small copy either way. So the queue moves in a second rather than a minute of swapping laptops, and nothing is recorded. On the second day the same laptop's microphone captions the presenter as they speak, across the bottom of their screen on the wall and under the small copy on everyone's page, about a second behind: the room could see them from the back long before it could hear them. Opening the page checks you in and joins the line; I press Next. A turn goes to a student whose site is answering while the class is running, which the course checks as it checks them in: a site that is down puts you beside the queue rather than in it, with the reason on your own page and one button to ask again once you've fixed it. Eighteen people are about to open that address, and a turn spent watching a page that won't load is a turn nobody gets back. Everyone gets the same two questions in the same words: what about this site is you, and show us a change, on your laptop first and then live. The second one is the reason a turn is seven minutes and not three, because a deploy takes a minute to land and that minute is when the room asks something. While someone is up, everyone else is on their site with a companion to think out loud with, sending the presenter a note for afterwards or a question for now, which goes on the wall with the asker's first name unless they'd rather it came from the room. Notes and questions reach the person they're about when the session closes, never during. Nothing from anyone's screen or microphone is recorded: the captions are on the wall while they're said and nowhere afterwards.

Each of these has an activity page, posted the day we did it, that ends with what to do if you missed it and, for anyone teaching, the plan the room played and how to run it without our site. And each has a walkthrough: the whole activity recorded end to end, every screen in the room side by side, a step at a time. The students in them are invented and the conversation with the agent is generated, but everything else is the software students actually use, driven the way they would drive it. We make them to check a flow before we run it, and they're the clearest answer we have to "what do you actually do in there?"

The Patterns in the Room

Three kinds of participant share a class: the students, the coding agent each of them works with, and the course's own agents, which teach rather than build. Five sessions in, these are the moves we keep coming back to for getting them to interact well. Each is small enough to borrow on its own, and none needs our software; the activity pages say what to use instead.

Pair by code, not by assignment. A student's page shows a code; they give it to whoever they sit down with. It survives late arrivals, odd numbers, and a room that won't start on time, and whoever's code was used goes first, which settles the one argument every pair would otherwise have.
One builds, one watches the asking. The partner's own screen shows the conversation with the coding agent as it happens, a few seconds behind, and the instruction is to watch how the builder asks, not whether the result is any good. Three shapes for what they see, I notice, I wonder, what if, and the notes go to the person they're about after class, so nobody reads about themselves while they're supposed to be watching someone else.
A companion that won't build. Beside the watcher sits a second agent that sees the same feed and answers most questions with a question to ask the partner. It never makes anything, so it can't turn into a second coding agent, and each seat gets its own: the critic's asks what she was looking at, the builder's keeps the list of what he was told. A switch starts a fresh one.
The same page, a different plan. Fresh Eyes is pair prompting with the roles renamed and the three shapes pointed at the work instead of the process; Going Live is the same page with no roles at all, both partners building and each seeing the other's conversation. An activity is a plan file: the sections, what each role is called, which companion each seat talks to. The software didn't change between them.
The course speaks through the coding agent. Rather than a third window, the course adds a short note to the end of every request a student's agent makes: the day's task, what good looks like, and a link the agent can use to report back. A few times an hour, only when something happened, a line about the partner, which the agent passes on in the course TA's voice: go find out what she did, and tell me about it. The student's answer comes back the same way and is checked against what the partner's agent actually did. Every word of it is on the activity page, because setting context for an agent is the skill being taught.
The room moves by hand, and it's on the wall. A session is a list of sections played from the front: next, again, stop. Nothing advances on a timer, because an instructor facing thirty people needs to run one more round or skip one, and a schedule can't be argued with. The projector shows the section the room is on and its clock, the pairs with a dot each for whether an agent has been busy, and who still needs a partner. We're already designing the opposite, each student paced by their own agent, because moving a whole room at once is disruptive; when it works, we'll say so here.
Music in turns. Anyone pastes a YouTube link from any course page and the room plays the queue, taking turns by who added what, with the adder's name on the screen. It costs nothing and it makes the projector the room's rather than the instructor's, which changes how the rest of it reads.
End by talking about it, with your name on it. The last section of every plan sends students to a short conversation about how the session went, run by the same engine as the admission interview, one per student per class day, attributed rather than anonymous because the site knows who is signed in. And nobody takes attendance: a student counts as here if they paired or left feedback that day, they can see their own record with the reason, and one click corrects it.

Eight again. What they have in common is that the coding agent is never the only other voice in a student's session: there's a partner watching, a companion asking, and a course that can speak through the agent when it has something worth saying. Whether that's the right shape is what the semester will tell us.

Head to Head

After the first Show and Tell, the sites students had built were competent and generic, and I wanted them to see what distinctive looks like before building anything else. The exercise that came out of that ran across the two class meetings I was away for. On the first, each student found eight personal websites and wrote a sentence on what made each one effective and another on what made it distinctive; a domain belonged to whoever found it first, so the class assembled a corpus of 117 sites nobody in the room had made. On the second, Head to Head: two of those sites side by side, live, with the finders' sentences and never the finders' names, and two questions, which is more effective and which is more distinctive. Pairs were dealt Swiss-style so every site was seen about equally, each student compared about thirty-five pairs in half an hour, and a Bradley–Terry model was fitted to the 760 comparisons separately for each question. The ranking is of sites the class found, not sites it made, which is what lets a room of beginners rank anything at all without the competition undoing the critique; the only thing anyone learns about a classmate is that they found a good one, and the leaderboard names people only where they chose to be named.

We revealed the standings in class on October 7 as a walk through the top ten, each site live on the wall for a minute of talk about what put it there before its finder appeared, and the two orders disagreeing was the most interesting part: several sites the room found most effective it did not find distinctive, and the reverse. The full results are public: every site in the draw with both ranks and the finders' sentences, and where the room split. The two activity pages are Ask the Agent, Then Eight Sites andBuilt for Us, Then Head to Head, each with how to run it without our site.

What the Agent Says Helps

There's one thing on this page the students didn't see until their first project was done. Late in August I asked the agent, from its side, what makes a conversation go well. I'm embarrassed to say I'd used it for more than a year before asking, and when we looked at the transcripts of a much larger course, almost nobody there had asked either. Its answer, condensed:

Say what done looks like, not how to get there. Before you ask, be able to say how you'll know it worked. Then give it the outcome and what must not change, and let it own the steps; dictating the implementation looks like diligence and gets worse results.
Say what you saw, not what you concluded. “The button does nothing on the second screen” is worth ten of “the click handler is broken.” The diagnosis is often wrong, and the agent is agreeable enough to chase it.
Never accept “done” without looking. “That should work now” is sincere and sometimes wrong. Thirty seconds a turn.
Correct it, out loud, early. It's deferential by design. People afraid to disagree get steamrolled by their own politeness.
Ask what would break before it breaks. “What would break if I changed this?” is what good users ask, and where they're learning.
Keep it oriented. Say what changed since last time. Ask for a summary of where things stand before anything big.
Calibrate how much you hand over. The whole app on day one and never more than a line both lose. The right size is learned by trying.
Ask it how to work with it. The move expert teams make with each other and almost nobody makes with an agent.

Eight, which is also the shape of the thing: two loops, each running on its own, touching again and again. We deliberately didn't teach these for the first month. Pair prompting's three shapes already circle a few of them, but as things to notice in a partner, not as rules. Once everyone had finished a first project, the students asked the agent the same question themselves, in rounds, about their own work (September 25), and saw this list beside the one they had just made. On October 7the first practice became a day's lesson, applied to the idea rather than the build: back up from the app you picked to the goal behind it, ask for several different ways to get there, and choose. The rest come one at a time, the same way, as the projects give a reason for them. They're also the agent's account of itself, and introspection is a hypothesis: if the students who look, say what they saw, and push back aren't the ones who ship, we'll teach whatever their conversations say instead.

What We're Building

Students work with Codex on their own computers, but every conversation with the model runs through a server the course operates. The setup is one line a student pastes into a terminal; from then on the course can see how each conversation goes and what it costs, and each student can read the same on their own page. None of it grades anyone, and nothing leaves the course.

What I expected to build on top of that was a teaching agent: a second agent that watches a student's conversation with the first and occasionally steps in, to ask a question, to notice a habit, or to hand the student their own patterns back as something to reflect on. What I built first was narrower, because two days of logs showed the course paying for another course's homework and a daily briefing. Give students an agent that costs them nothing and the first thing you learn is what else they'd use it for. So the watcher that exists today asks one question of each conversation, whether it's course work, and writes the answer down where I can read it. The teaching agent came later, and smaller than I pictured it; that's the last section on this page.

The rest of what we run lives in this site. Pairing is by code: you show yours to whoever you sit down with, which survives late arrivals and odd numbers. The observer's page shows their partner's conversation as it happens, with a companion beside it that can see the same feed and answers most questions with a question to ask the partner. A class session is a plan, played from the front of the room like a playlist, and nothing advances on its own: an instructor in front of thirty people needs to run one more round or skip one, and a schedule can't be argued with. Fresh Eyes is the pair prompting page with a different plan, one that names the two seats and gives each its own companion. The projector shows the section the room is on with the time left, the pairs, who still needs a partner, and the music: any student pastes a YouTube link from any course page, and the room plays the queue in turns by who added what, with the adder's name on the screen. Every session ends the same way, with a short conversation about how it went, attributed rather than anonymous, because the site knows who is signed in and an anonymity it can't keep would be worse than none. And nobody takes attendance: a student counts as here if they paired or left feedback that day, they can see their own record with the reason beside it, and one click corrects it.

Personalized Pedagogical Agents

I can be with one student at a time. Their agent is with them for the whole hour. Many of them move at their own pace, and moving the whole room together is fundamentally disruptive. The most useful teacher in the room may turn out to be the thing already sitting beside each of them. That's what I mean by a personalized pedagogical agent: not a tutor bolted on beside the work, but the student's own agent, knowing a little about who it's working with and where they are today.

The mechanism is small. Every conversation already runs through the course's server, and the server can add one short note to what the agent sees before the model answers. The note is context, never an instruction, and it says so where the agent can read it: the student's request comes first. A check refuses any note that tries to give the model orders, and every note a student's agent receives is published to that student, word for word, on their own page. They keep their agent, their project, and their transcript. What changes is how much the thing beside them knows.

Going Live was the first session that used it. Each agent was told which phase of the activity its student was in, and each student moved on when their own site came online rather than when the room did; my "next" from the front of the room was advisory for the first time. The agents also knew, rarely and on a cooldown, what that student's partner had just done—a deploy, a long run, a quiet spell—though never what the partner typed. The move I didn't expect was the one that isn't a report: rather than telling a student what their partner had done, the agent says go find out and tell me about it, and afterwards the course reads the account against the partner's own record. The agent's job that hour was to get two people talking to each other. Every note it was given is printed on the activity page, word for word, because students should be able to read what their own agent was told.

What's Out There (October 2) was the second, and the first with a constraint rather than a task: for a few hours around class, every agent in the room knew that the day was research into the problem behind a student's chosen idea and not the solution, that the idea had to be someone else's, and where to report which one the student chose. The pick itself travelled that way, from the student to their agent to the course, and the projector counted them as they landed. The note states the constraint as a fact about the class; it never tells the model what to refuse, and a student who insists can still get their way, on the record. That is the line the next section is about.

What Done Looks Like (October 7) was the third, and the first where the note carried a practice: every agent knew the student's own pick, that the day was for backing up from the idea to its goal and weighing several ways to get there, and where to record the goal and the approach the student settled on. It was also the first day the room assigned partners instead of letting people swap codes, by one rule: nobody sits with someone whose idea they picked, because those are the people they're building for. The pair page showed each student their partner's name and photo, the projector showed every pair, and latecomers were seated as a third. Codes stay the default; a plan asks for assignment when it has a reason to.

Two lines we hold on purpose. The agent's curriculum is the channel, not the content: it can notice how a student talks to their agent, and it never points at a gap in the student's project, not the missing user, not the wrong assumption, not the feature that shouldn't exist. An agent that points there eats the thing we are trying to teach. And when the tests go green on something that doesn't work, nobody warns them; that betrayal is the best teaching moment in the course and it has to land before anyone explains it. Whether any of this changes what students actually do, I don't know yet. We logged these conversations for two weeks before we started adding anything to them, which is the only reason the question stays answerable. If you want to try the idea without running a server, most of it fits in a paragraph of a project instructions file the student can open, edit, and delete, which is where a course's standing voice belongs anyway.

Follow Along

We're looking for educators who are excited about what comes next. If you want to follow along, borrow what works, or eventually run the course yourself, leave your address below. Expect a message every few weeks during the semester: what we're learning, and what we're using. What we make for the course, the syllabus and the activities, goes up on this site as we use it, whether or not you sign up. Every message has an unsubscribe link, and you'll confirm by email before anything is sent.

You don't have to be in computing. If you teach writing, design, or studio critique, you already teach most of this course, and we'd rather learn from you than reinvent it. A unit inside your own course counts too; it doesn't have to be a whole semester. And "we," for now, is me and the students. There's no team yet, which is part of the invitation.

Or just write: challen@illinois.edu. I'd like to hear what you're trying too.