Conversational
Programmingdev
A hand-drawn skyline: the Illinois campus inked on the left gives way to an imagined future city, then to pencil sketches, then to a bare horizon line running off the page.

Syllabus

CS 199 ASK: Conversational Programming, Fall 2026, University of Illinois Urbana-Champaign.

  1. Draft syllabus. This is a new course, taught for the first time. Expect this document to change as the semester goes on; the current version is always here.
  2. Open seminar. CS 199 ASK is letter graded, 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. I’m also very nervous. 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:

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

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. I’ve seen it happen. I’ve worked with colleagues here with no technical background who picked up this skill quickly.

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. There may be computer science ideas that turn out to be useful, that a bunch of people run into, that are worth knowing. If so, we’ll discover them together. 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.

Nobody Knows How to Teach This

Here’s the honest part, and the reason I’m nervous. Nobody knows how to teach this skill. It is the most powerful skill in computing, and nobody knows how to teach it. Next month I’ll be presenting to a small group of researchers who think hard about this, and the title of the paper is, literally, that nobody knows how to teach this new skill.

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, four days out of five when I go back and look at the record. I’ve been using AI to write code for about a year, and since the start of this calendar year I have not read, written, or debugged source code for any of my projects. So I know this is possible for me. That’s different from knowing it’s possible for you. I’ve watched students and colleagues with no technical background start building things, so I believe it is. But I don’t know what you need to learn to be good at it. Nobody does yet. We’re going to figure it out together.

That’s why I think of this course as a journey, an expedition. This capability is brand new; coding agents that can really do this have existed for about a year. We’re going together, we’re going to work as a group, and we’re going to build on what happens in this room.

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. You’ll practice here with each other, and you can practice outside of class if you want to. A typical class might look like this: a few minutes of someone showing what they made, most of the period building with a partner watching, and the last stretch talking about where it got stuck. Here’s what we’ll do together.

Pairs. You’ll sit down with a partner. One of you works on your project; the other observes how you work with your coding agent and gives feedback on what you’re actually building. Then you switch. Observing means following the conversation, which is text, so it can happen on your own screen at whatever size you need. Most people in the room will be doing this for the first time, and the partner watching you is figuring it out too. Watching someone else’s process, and having someone watch yours, is one of the most useful things you can do, and you get both perspectives.

Sharing out. At larger scale, we’ll have moments where people share what they’re working on and reflect on how it went. Anything shown to the room is also shared to your own screen. I want to see the thing you’re building, mainly because I’m excited to see what you create. But I also want us talking about where you got stuck, what took longer than it should have, what was hard, and what you could improve. That reflective loop is how we’ll get better.

Critical thinking. If you ask me what matters most in working effectively with a coding agent, it’s this: the ability to look at something and decide whether it’s good, and if it isn’t, to figure out what needs to change and articulate it. We’ll build that ability in pairs, in share-outs, and by using each other’s work and giving feedback on it. 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.

A coding agent built for learning. The agent you use in this course will work a little differently from one you’d set up on your own (which you could do). It’s designed to help you reflect: to notice when something was harder than it needed to be, and to help you get better at describing what you want.

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: whether there’s content, best practices, or exercises worth bringing in next time. 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.

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.

I know this is possible because I’ve watched it happen. Last spring, students in my other course, none of them with a technical background, built an aquascaping tracker for their tanks and a management platform that replaced the apps their sorority chapter was paying for. And that was a course about understanding AI. Imagine what you’ll build in a course about building.

One of the most valuable things you can do in technology right now is iterate. These tools make it quick to build a website, look at it, decide you don’t like it, change a lot, or start over. Build a feature, see if it works, ask people about it, revise it. It used to be that changes took so long that once something worked, you didn’t want to touch it. That’s over. Changes are easy, and they can be made safely. We’re going to lean into that.

What you build is largely up to you. I may establish some themes as we go:

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.

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. There may be some value in slowing parts of this down and doing them by hand, but that’s not what this course is about. 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. Computer scientists often don’t do much of that, because building took so long that we’d finish and realize we never understood the problem. Now that building is quick, we can spend more of our time thinking about problems.

Your Instructional 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. We set everything up together in the first week. There’s no development environment to learn. Bring a laptop you can install software on (macOS, Windows, or Linux).

There is no textbook. Students should expect to purchase some things along the way. Depending on what you choose to build, a project may need something paid, such as hosting so other people can use it, a domain name, or access to a data set or an API; 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 August may not be what we’re still using in December. The technology is changing that rapidly, and learning to move between tools may be useful.

Grading

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

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.

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 August 24 through December 9. There is no class on Wednesday, August 26; we begin Friday, August 28. Fall Break runs from Saturday, November 21 through Sunday, November 29. We anticipate that class activities will wrap up before Reading Day (December 10); there is no final exam.

A week-by-week schedule will appear here as the semester takes shape. Since nobody has taught this course before, we would rather publish a schedule we can keep than one we will rewrite.

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: