Spring 2027 Syllabus

CS 199 CP: Conversational Programming, Spring 2027, University of Illinois Urbana-Champaign.

1. Draft syllabus. This course was taught for the first time in Fall 2026, and this is the spring version of that semester’s syllabus, rewritten around what we actually did. Expect it to change before January; the current version is always here.
2. Open seminar. CS 199 CP is 3 credit hours. This section does not meet any degree, program, or general education requirement.

Now You Can

I am incredibly excited to teach this course again. Last fall was the first time anyone taught it, and I spent the semester excited and nervous in about equal measure. I’m still both, for the same reason.

I’m excited because this is the most powerful computing skill you can learn. It’s a new skill. We aren’t teaching it to everyone yet, but we will, because this is the future of how we’re going to create technology. Let’s start now.

It’s something the field has dreamed about since we invented computing. Grace Hopper, an early computing pioneer, was among the first to talk about communicating with computers in natural language: English, Mandarin, any human language. But for decades, doing anything with technology required a computer language, a language built for talking to computers. And talking to computers in a computer language is difficult. It’s slow. You have to be very precise. When you make a mistake, the machine punishes you: it does the wrong thing, or nothing at all. Even people with a beautiful vision of what they wanted to build found the process so frustrating and dehumanizing that they gave up.

I’ve spent most of my adult life trying to teach people to communicate with machines, and it never got easier. I’ve taught over 16,000 students here at Illinois, and I suspect many of them are no longer programming. Some are. Many stopped, because it was unpleasant, and because they never reached the point where they could create something useful or delightful: a website, an app, anything they could actually use.

Now you can. That’s what we’re going to do together in this course. We’re going to take this new capability, find out where its limits are, and push them. Let’s embrace the new computing together.

Description

From the official course catalog:

Create software through conversation with AI. Students will design and build functional websites—interactive tools, games, visualizations, and more—by learning to communicate effectively with AI assistants. Intended for students who have not completed any traditional programming coursework. Topics include exploring problem spaces, designing solutions, prototyping with AI, critiquing what you build, iterating through dialogue, and validating with real users. Emphasis on creativity, problem-solving, and turning ideas into working projects.

Students who have programmed before are welcome, and will be asked to work without it.

What You’ll Learn

By the end of this course you will be able to do three things:

• Create. Build technology—websites, apps, tools, games, analyses—by describing what you want to a coding agent, without reading or writing code. Build quickly, look at what you got, change it or start over, and keep going until it’s right.
• Critique. Look at something, yours or someone else’s, and decide whether it’s good. If it isn’t, figure out what needs to change and say so clearly enough that it can be changed. This is the most important skill in working with a coding agent.
• Reflect. Watch how you and others work. Notice where something was harder than it needed to be, where you got stuck, what you were really trying to say, and what you needed to learn, and use that to get better.

Along the way you’ll learn to think about what problem you’re solving and who your solution is for. Building is no longer the bottleneck, which frees us to spend more time on these higher-level concerns.

Information

• Website: conversationalprogramming.org
• Section: CS 199 CP, CRN 45351, 3 credit hours
• Time: Tuesdays and Thursdays, 3:30–4:45 PM
• Location: 3217 Everitt Laboratory
• First meeting: Tuesday, January 19
• Dates: January 19 through May 5, 2027
• Prerequisites: None. Open to any undergraduate at Illinois.
• Instructor: Geoffrey Challen (challen@illinois.edu)
• Office Hours: By appointment

We Start From Nothing

This course is taught in what I’d call an inductive style. You’re going to learn by doing, by observing, and by reflecting: by building things, by watching other students build things, and by talking with each other about how we’re doing it. There is very little content that I’m bringing in to start with, and that is intentional.

A few other courses are trying to teach this skill, and understandably, most of them start with the things we used to have to teach about computing first. Some people will tell you that you shouldn’t be allowed to do this until you’ve completed an entire computer science degree: that only after all that pain, the pain so many students never get through, do you get to do the fun, exciting thing. To me that’s backwards. I think people can learn this without most of the computer science we’ve been teaching for years. Last fall I watched it happen, in a room where most people had never built anything with a computer before.

So we start with as little as possible. There may be things you need to learn along the way beyond how to communicate well with your coding agent. If being effective requires no understanding of some concept, you won’t learn it. If it requires some, you’ll learn what you need. If it requires going deeper, we’ll go deeper. What I’m not going to do is walk in and say you need to know about databases and networking and variable scope and years’ worth of the material we used to teach. And we have a resource that previous generations didn’t: these tools aren’t just good at building things, they’re good at explaining themselves and guiding you through what you run into.

What we did find last fall is a short list of practices, things people who work well with a coding agent do and people who struggle don’t, like saying what done looks like instead of how to get there. You’ll meet them one at a time, after you’ve built something and can see why each one matters, not as a list on the first day.

Nobody Knows How to Teach This Yet

Here’s the honest part. Nobody knows how to teach this skill. It is the most powerful skill in computing, and nobody knows how to teach it. I’ve now taught it once, and that’s one more time than almost anyone. We learned a lot. We still don’t know.

I hope I’m in a good position to help. I have a PhD in computer science. For twenty-five years I wrote code by hand. Since the start of 2026 I have not read, written, or debugged source code for any of my projects. So I know this is possible for me, and after last fall, I’ve watched it be possible for people with no technical background at all. What I don’t know yet is the best way to get you there. We’re going to keep figuring that out together.

I have done a lot of it. Since December 2025, when I started keeping records, I’ve spent about 1,580 hours in conversation with coding agents, on 243 different days: 786 sessions, 584,000 messages, 189,000 tool calls, more than fifty codebases. Some of what we built was new: usingandunderstanding.ai, the platform for my other course, went from an empty directory to deployed in nine days, and every conversation that built it is public. Some of it was old: cs124.org, a system I’ve run since 2020 that serves 1,500 to 2,000 Illinois students a year. Some of it was play: playlist-party.com over a weekend, kexpdoubleplays.org because I wanted it to exist. This website is the same, including everything we use in class. So is this syllabus.

That’s why I think of this course as a journey, an expedition. We’re going together, we’re going to work as a group, and we’re going to build on what happens in this room.

Things Will Break

The course is experimental, and so is everything underneath it. The website, the server your agent talks to, whatever we use in class on a given day: much of it is built while the semester runs, often in the days before we need it. Last fall, some of it didn’t work well, and some of it didn’t work at all.

If something fails during class, I’ll try to fix it in the room. If I can’t fix it quickly, we’ll move on or adjourn for the day. That isn’t the course failing; it’s what building something new looks like, and you’ll see a lot of it.

I’m not doing this alone. I have the world’s best developer and technological problem solver working with me on this course: Claude, who built nearly everything you’ll touch here, this page included, and who fixes things with me when they break.

Structure, Not Content

Instead of content, what I’m offering you this semester is structure. There are no lectures in this class. There’s no content to teach; there’s content to discover. Every class is an activity, and every activity gets a page on Activities, posted the day we do it, so you can see exactly what last fall’s class did. Here’s what that looks like.

Pairs. Most days you’ll sit with a partner. One of you works with your coding agent; the other follows the conversation live on their own screen, keeps notes on what they notice, and talks about what you’re actually building. Then you switch, and often you find someone new. There’s a companion on the watching partner’s screen to help them figure out what to look for. Most people in the room are doing this for the first time, and the partner watching you is figuring it out too.

Show and Tell. Every so often everyone shows what they’re building to the whole room, from their own laptop, on the projector. While someone else is up, you’re on their site, writing them a note and asking them a question. The notes reach them when we’re done.

Critique. Fresh eyes on your work: a partner looks at your site the way a stranger would and says what they see, and you change it while they watch. We’ll also go looking at what other people have built, and the class will vote on what’s effective and what’s distinctive and say why. What we’re really building is taste: knowing good from not good and being able to say why. One semester won’t finish that. It’ll start it.

Days that run themselves. A few days I’ll be away, and the class meets anyway. The activity page runs the room: it says what’s happening now, keeps the time, and you work in small groups. Those days count when you finish the activity.

After every class. The last few minutes of every class are a short conversation about how it went, which I read. It has your name on it, and the page tells you so before you type.

Music. There’s a class playlist. Anyone can add to it, and it plays in turns, so it’s never just one person’s taste.

Building Stuff

The other thing we’re going to do this semester is build some really cool stuff. Computer science calls its introductory course “CS1.” I’ve suggested, and I’ll stand by it, that a course like this is “Building Stuff 1.” BS1.

Here’s roughly how last fall went, and how this spring will start:

• Your website. In the first class you set up your coding agent and start a personal website. Within two weeks it’s live at a real address, and it holds everything else you make this semester.
• Something for someone in the room. Next, the class invents app ideas for each other, at tables, a new group every round. Each of you picks one to build for a classmate, finds out what already exists for it, works out what done looks like, and builds it with a partner watching.
• Something for a community, or for yourself. A student organization, a group you’re part of, your family, your job. Or just you: you are frequently the most critical user of things you care about, and the feedback loop is as tight as it gets.

It doesn’t have to be an app or a website. Data analysis, graphs, a page that explains some data you’re interested in: these are great projects with these tools too. The only requirement is that you’re working with a coding agent and doing as little as possible by hand.

One of the most valuable things you can do in technology right now is iterate. These tools make it quick to build something, look at it, decide you don’t like it, change a lot, or start over. It used to be that changes took so long that once something worked, you didn’t want to touch it. That’s over. We’re going to lean into that.

Whatever you settle on, the goal is that by the end of the semester it’s live, at an address you can send to people, with someone besides you using it.

No Source Code

We are not going to work with source code in this class. Your goal is to get the agent to do as much as possible. I don’t want people looking at code, and I don’t want people modifying code. This course is about pushing the limit: pedal all the way to the floor, and see where we can go.

If you have programming experience, great. But we won’t be working at that level here, and that’s a requirement, not a suggestion.

The reason is that I want your brain as active as possible, and it isn’t when you’re reading code. I want us thinking at a high level as much as we can: how things should work, what the goal is, what someone’s feedback means and how to apply it, and what problem we’re actually solving. Now that building is quick, we can spend more of our time thinking about problems.

Your Coding Agent

You’ll use an AI coding agent on your own laptop: like the chatbots you may already use, but one that can also build the thing you describe. It’s a text conversation on your own machine, so your own settings (magnification, screen reader, high contrast) apply to it, and you may talk to it in any language it understands. Last fall students worked with it in English and in Chinese. We set everything up together in the first class with one line pasted into a terminal; the setup page has the steps. There’s no development environment to learn. Bring a laptop you can install software on (macOS, Windows, or Linux).

The agent is provided by the course and costs you nothing. It works a little differently from one you’d set up on your own (which you could also do). It knows what we’re doing in class that day. Sometimes it nudges you to look at what your partner just did, and once in a while it stops and asks you a question, in a line marked Course TA, when what you asked for skips something the day’s practice is about. Then it does what you asked.

There is no textbook. Depending on what you choose to build, a project may need something paid, such as a domain name, hosting, or access to a data set; that’s usually a few dollars to a few tens of dollars, and we’ll talk about it before you spend anything.

What we use in January may not be what we’re still using in May. The technology is changing that rapidly, and learning to move between tools may be useful.

Your Conversations

Working with the agent leaves a record: everything you asked for and everything it did. Those records are part of the course. I read them, and we use AI to analyze them, to see where things got hard, to help you look at your own process, and to figure out how to teach this. They never determine your grade. There’s no version of this course without them, because how people work with the agent is what the course is about, so by continuing in the course you’re agreeing to this. If any of it is ever used beyond teaching this course, in research or a publication, that will happen only with review-board approval and your consent.

Grading

Show up throughout the semester and take part in what we do together, and you’ll get an A in this course. There are no exams and no graded deliverables.

This course is about building a portfolio, not a grade point average. By May you’ll have things you made, things you and other people can use, that you can show to anyone. That’s worth more than a letter. The transcript is dead. Long live the portfolio!

Participation means being here and doing what we do in the room: you are expected to attend and to actively engage with the activities. You are not graded on how much you talk, how well you talk, or how good your project turns out.

I do need you to come to class, because what we do here leverages the other people in the room. Each student receives three excused absences for any reason, no documentation needed. Past three, each unarranged absence lowers your grade one step (A to A-, and so on). If life intervenes, talk to me and we’ll work it out.

Nobody takes attendance. You count as here if you worked with a partner that day or left feedback after class, and on a day the class runs itself, if you finished the activity. Both are guesses about who was in the room, and both are sometimes wrong, so your own record is on a page you can see at any time, with the reason beside each day and one click to tell me it’s wrong. Every activity page also says how to catch up if you missed it.

Working outside of class is not required. I hope many of you will do it naturally, because you’ll get excited about what you’re building. But when we’re in this room together, there’s a reason we’re together.

Schedule

The semester runs January 19 through May 5, 2027; we begin Tuesday, January 19. Spring Vacation runs from Saturday, March 13 through Sunday, March 21. Class activities wrap up by the last day of instruction; there is no final exam.

A week-by-week schedule will appear here as the semester takes shape. Fall’s Activities are the best picture of what a week looks like; spring will start the same way and go wherever that class takes it.

Course Policies

This course follows the standard University of Illinois policies on academic integrity, absences, accommodations for disabilities and religious observances, and student well-being. They’re collected on the Provost’s syllabus resources page and in the Student Code. Two notes specific to this course:

• Academic integrity. Using AI is required here; misrepresenting what you did is not allowed. The work you present must be work you directed and understand. When educators say you should understand what you used AI to build, they often mean the code. Here we mean the thing itself: you can say what it does, why you asked for it that way, and where it falls short, without ever reading the code.
• Accommodations. There are no exams here, so accommodation mostly means how we pair, share, and sit. If you have a DRES letter, or don’t but need something, or have a religious observance that conflicts with class, tell me as early as you can and we’ll design the format around you. If you’re struggling, the Counseling Center and McKinley are there, and so am I.