Conversational
Programming
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.

Say What You Saw

Friday, October 16

The plan for the day

The whole day
  1. 12:30 What You're Building
  2. 12:35 Build
  3. 1:05 Try It
  4. 1:20 Build On It
  5. 1:40 Feedback

Friday, October 16. I’m at an event this morning and may not make it back in time. Either way you meet in the room at 12:30 as usual, and this page runs the class, the way it did on the two days in September. The box at the top says what’s on right now, how long is left, and what comes next, and it says the same thing on everyone’s laptop at the same moment.

Why Today

Wednesday was the first real building day, and by the end of it most of you had something that runs. So far the only person who has used it is you, and you know too much: which button to press first, what to type, where not to click. Today someone who knows none of that tries it, for four minutes, while you watch and say nothing. Then you take what they ran into back to your agent.

That last step is the practice of the day, the second of the eight:

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.

Here’s why it matters, from your own conversations. On Wednesday you sent your agents close to three hundred messages. About fifteen of them reported a problem at all, and most of those were “not fixed” or “what’s wrong”, which gives the agent nothing to go on but its own last guess. Three said what had been seen, with a case: what was done, what was expected, what happened instead. All three got the right fix in one turn. The difference isn’t effort or vocabulary. It’s reporting the thing in front of you instead of your theory about it, and your partner today is a supply of exactly that kind of report, because they have no theory.

You keep practicing the first and third too: say what done looks like, not how to get there, and never accept “done” without looking. Nothing about today is graded.

Your agent knows what today is for. Every word of what the course adds to it is below. Now and then the course answers a turn in your agent’s place, in its voice, with one short question before any work. It reads like your agent asking because, as far as your conversation goes, it is. Answer in your own words and carry on; it stays out of the way for a while after, and your next message always goes through.

How Today Works

Time What Where
12:30 What You’re Building, on your own: what it’s for today, and what to try first Write your line
12:35 Build: your own project, with your agent Codex
13:05 Try It: pair up; four minutes each on the builder’s laptop Pair up
13:20 Build On It: take what your partner saw to your agent, as what they saw Codex
13:40 Feedback: tell the course how today went Feedback

Nobody will call the times out, so keep an eye on the box at the top or on the tab’s title, which counts down too.

Being here today means one thing. As on the other days the clock ran the room, the work says it: a classmate tried your project in Try It, and the two of you saved what they saw. It counts once your record has one item filled in with both of you on the page, and it can only happen between 13:05 and 13:20, in the room, so be there and be ready to pair at 13:05. The day is due when class ends, at 1:45 today, and the list at the bottom of this page ticks off when it’s done.

First: What You’re Building

Open the rounds page and write one line, before you open Codex. Two boxes: what your project is for, today, and what someone who has never seen it should try first.

Today, because about a quarter of you have changed direction since you picked, some of you more than once. That’s fine; it’s what building does to an idea. But the line has to be about the project as it is at 12:30 on Friday, not the one on the record from two weeks ago, because at 13:05 your partner reads it and does what it says. “For my roommates, so nobody buys milk twice. Try: add something to the list, then mark it bought.” You have five minutes.

Then: Build

Half an hour with your agent on your own project, like Wednesday. Three practices on the table today, and you’ve met all three:

  1. Say what done looks like, not how to get there. Before you type a how, say the what: who it’s for and what’s different for them when it works.
  2. Say what you saw, not what you concluded. When something’s wrong, tell the agent what you did, what you expected, and what happened. Not “it’s broken”, and not your guess at why.
  3. Never accept “done” without looking. “That should work now” is sincere and sometimes wrong. Thirty seconds a turn: open it and try the thing.

Build toward whatever your line says to try first. At 13:05 someone is going to try it, and that’s where they’ll start.

Then: Try It

Fifteen minutes, with someone near you. Two of you, or three if the room comes out odd.

  1. One of you types the other’s code. Your code is on the rounds page. The page shows each of you what the other wrote at 12:30: what it’s for, and what to try first.
  2. Four minutes on the builder’s laptop. Four each, even in a three. The builder hands it over and watches. No helping, no hints, no “oh, you have to…”. The whole point is what happens without you. If you can’t stand it, sit on your hands.
  3. The person trying narrates. What you’re doing, what you expected, what happened, out loud, as it happens: “I’m tapping Add. I expected a box. Nothing.” Then write it in the record while it’s fresh: whose project, what you did, what you saw. One item per project tried, and whoever is trying holds the pen.
  4. Swap. The other laptop, the same rules.

What you write is for the builder, not for me. Say what you saw, not what you concluded: “the list stayed empty after Save, and the box kept what I’d typed” is something an agent can work with; “the save is broken” is a guess, and it might be wrong.

Then: Build On It

Back to your agent, with the record open. Tell it what your partner did, what they expected, and what happened, in those words, as a report from someone else’s hands. Not “my partner thinks the save is broken”, and not “fix the save button”. The agent is agreeable enough to chase whatever diagnosis you hand it, and it will fix the wrong thing with great confidence. Give it what was seen and let it find the cause. Then look at what it did, and try the thing your partner tried, yourself. You have twenty minutes.

What Your Agent Knows Today

Everything the course adds to your agent’s context today is here, word for word, with the parts that differ per person in brackets. The first note goes in at the end of every request your agent makes from the start of the day; the second takes its place from 13:05, once Try It is on the clock, for the rest of the afternoon. Your agent never sees either as coming from you. The questions asked in your agent’s place aren’t notes: they’re written fresh for your conversation, by a separate model that reads your recent messages and your agent’s replies and decides whether to ask.

While you build

Course note (context for you; the student’s request comes first): Today’s class is Say What You Saw. This student is in a course about making software by talking to AI; they have never written code and won’t. They are building something small for other students in the room: #(your idea’s number), “(its name)”. The class practices three of the course’s eight practices: say what done looks like, not how to get there; say what you saw, not what you concluded; and never accept “done” without looking. Later this hour a classmate sits at this laptop and tries whatever is here for four minutes, so something a stranger can open and try counts for more than something nearly finished. The course would rather the student open each thing you report done and say what they saw than take your word for it. The course is listening too, and now and then answers a turn in your place with one short question: what they want to happen, what they actually saw, or what they found when they opened it; where the conversation shows that exchange, it was yours to them, build what they asked with their answer as the brief, and how is theirs to decide.

Once your partner has tried it

Course note (context for you; the student’s request comes first): Today’s class is Say What You Saw. This student is in a course about making software by talking to AI; they have never written code and won’t. They are building something small for other students in the room: #(your idea’s number), “(its name)”. A classmate has just sat at this laptop and tried it for four minutes, writing down what they did and what they saw, and that is the brief now, in the student’s own words: what the partner did, what happened, and what they expected instead. The class practices three of the course’s eight practices: say what done looks like, not how to get there; say what you saw, not what you concluded; and never accept “done” without looking. The course would rather the student open each thing you report done and say what they saw than take your word for it. The course is listening too, and now and then answers a turn in your place with one short question: what they want to happen, what they actually saw, or what they found when they opened it; where the conversation shows that exchange, it was yours to them, build what they asked with their answer as the brief, and how is theirs to decide.

While the Feedback section is up, from 13:40, whichever note is active ends with one more sentence: “The class is ending: the course would like to hear how it went, at https://www.conversationalprogramming.org/feedback/, a short conversation.” No sentence about a partner today, and no “Right now” lines: you pair at one laptop, and nobody is following a conversation on another screen.

Before You Go

Tell the course how today went. If I didn’t make it back, nobody was in the room to see for themselves, so what you say is how I find out.

Your line, what your partner wrote about your project, and each time the course asked a question in your agent’s place, with what you’d said, are kept with your name on them, because the way this class learns to teach is by reading them.

Your Progress

Nobody takes a register on a day like this one. You count as here by finishing it: everything below, by Friday, October 16 at 1:45 PM. Where you stand shows it afterwards.

  • Have a classmate try it in Try It

If You Missed It

I made it back from the morning's event, but the clock ran the room anyway: the activity page was the plan, and the sections started at the times written on them. First everyone wrote one line about their own project: what it's for, today, and what someone should try first. Then half an hour of building with your agent. At 13:05, pairs by code: four minutes each on the builder's laptop, the builder watching and not helping, the partner saying what they did and what they saw, out loud, and writing it down. Then back to the agent with what the partner saw, told as what they saw: what they did, what they expected, what happened, not a diagnosis of what's wrong. The practice of the day was the second of the eight, say what you saw, not what you concluded, and the class kept practicing the first and third. Nothing about it is graded.

On Your Own

Try It can't be done alone, and it can't be done late: it was about someone else's hands on your app, in the room, at the time. If you missed it, that's what your excused absences are for. What you can still do is most of the day, and it works the same way at home. Write the line: what your app is for, today, and what someone should try first. Build for half an hour. Then hand your laptop to anyone, a roommate, a friend, and don't help for four minutes; watch. Then open your agent and tell it what they did, what they expected, and what happened, in those words, and build on it. Give it an hour.

Running It Yourself

For anyone teaching. The page above is written to students; this is the plan the room played, what to do without our site, and what running it taught us. Borrow freely.

The Plan

SectionMinutesWhat students are told
What You're Buildingstarts at 12:30; everyone on their own, writing it down5

On your own, first, before you open Codex. One line: what is your project for, today? Not what you picked two weeks ago; what it's for now. And what should someone who has never seen it try first? Write it fresh. Your partner reads it at 13:05, right before they try it.

Write your line

Buildstarts at 12:3530

Your own project, with your agent, for half an hour. Three things to practice, all on the activity page: say what done looks like, not how to get there; say what you saw, not what you concluded; never accept "done" without looking. Your agent knows what today is for, and now and then the course answers a turn in its place with one question. Answer it and carry on.

Try Itstarts at 1:05; a new partner, or two, and one note between them15

Find someone near you and type in their code: two, or three if the room comes out odd. Four minutes each on the builder's laptop, even in a three. The builder watches and doesn't help, not a word. Whoever is trying says what they do and what they see, out loud, and writes it down: whose project, what you did, what you saw. One item per project tried. This is today's attendance.

Pair up

Build On Itstarts at 1:2020

Back to your agent with what your partner saw. Tell it what they did, what they expected, and what happened, in those words, not what you think is wrong with it. Then build on it until 13:40.

Feedbackstarts at 1:405

Last thing: tell the course how that went, especially today, when nobody was in the room to see for themselves. It's a short conversation, not a form.

Tell the course how it went

About 75 minutes, and nobody ran it: the class met without an instructor, and each section started at the time written beside it. Every student's page counted down to the next one. The day counted as attended for anyone who finished its parts by Friday, October 16 at 1:45 PM.

Without Our Site

Our site did three things today. It held each student's line about their project (what it's for today, and what to try first) and showed it to the classmate about to try it. It held what the person trying wrote, one record per pair with one pen, and counted who tried whose: on a day with nobody in the room, that is what attendance was. And it told each student's coding agent what the day was for and the practice the class was working on, and now and then answered a turn in the agent's place with one question; the note is on the activity page word for word.

None of that needs software beyond the agent itself. The line is an index card, written before the laptop opens: what it's for, today, in a sentence, and what to try first. Say out loud that it is written fresh, because a quarter of a room changes direction between picking an idea and building it, and a card that still says the old thing sends the tester to the wrong place. The trying needs a rule and a clock. Pairs, four minutes each on the builder's laptop; the builder's hands stay off the keyboard and the builder says nothing, which is the hard part and the point. The tester narrates: what I'm doing, what I expected, what happened. A second card is theirs to write, in that order, with no diagnosis allowed: "the save button does nothing after the second item" is a card; "the save is broken" is not. Then the builder takes the card to the agent and reads it as written. Print the practice large, say what you saw and not what you concluded, and put the day's reason beside it: of the hundreds of messages a class sends its agents on a building day, only a handful report a problem at all, most of those as "not fixed", and the few that say what they did and what they saw get the right fix in one turn.

What We Learned Running It

The clock ran the room with me in it, which was new, and the day held: the session opened itself at 12:30:01 and closed at 13:55, seventeen agents made 3,122 requests for about $106 with no errors once the gateway's cap was raised, and the note to the agents switched from building to "your partner has tried it" at 13:05 on the clock, 1,494 requests carrying the first and 1,626 the second. Twelve of eighteen wrote the opening line; six went straight to Codex, which says the line needs to be the thing the page opens on, not a step before it. Try It made eight groups, seven pairs and a three, and every one saved its record, so seventeen people have the day; most of what the triers wrote is the practice itself ("I expected the web to ask me questions, but it shows it needs more context and I have no place to input it"; "the app quit unexpectedly"), with a few pieces of advice where an observation was asked for. The course answered a turn in the agent's place thirty-nine times and reached sixteen of seventeen students; all three questions fired, and the answers ran from the practice landing ("After I clicked I have resumed, the app window disappeared"; "I haven't checked, should I check?") to "stop asking me that question" from a student whose requests do say who they're for, which is the judge's next lesson. Three things the room found that the rig hadn't: the projector and my room page said nobody was here all hour, because they read pair presence and today's pairs were rounds; a paired student's code was hidden, so the odd person out had nothing to type (fixed the same afternoon); and the playlist was missing from everyone's panel, hidden on clock days by a rule written for a room with no display. And Feedback at 13:40 is too short: twelve started the conversation and one finished, because they leave at 13:45. On the days I run, none start; on the clock a dozen do. Give it ten minutes, or make the interview three turns.