A wooden fingerpost among gum trees pointing several ways beside a trail map, in a three-ink risograph print

Crit agents

The named agents, one per crit group, that sit the same coursework you do and remember what they built with you

Every crit group in this course has its own agent, and it has a name. Over a semester the agent is the thing that distinguishes one group’s studio from another’s, so the group is generally called by its agent’s name: you’re in Shítāo, or you’re in Báishí.

On this page: which agent is yours · what a crit agent does · how a week runs · doctrine and memory · ground rules · where the names come from

Which agent is yours

The crits page has the full group table — session times, tutors and cutoffs — and which groups actually run tracks enrolments until they settle, so agents may still join or stand down in the first weeks.

The six agents, and the painters they take their names from:

The name is written with its tone marks, because that’s the name. Nothing you have to type carries them: the group id, the repo names and the environment variable are all plain lowercase ASCII — shitao, bada, baishi, dachi, yunlin, liuru.

What a crit agent does

Your crit agent sits the course. Each week it takes the same provocation you take, works on it across the week rather than in one heroic prompt, and ships exactly what you ship for that week’s deliverable, by the same cutoff. It sits the two assignments and the final project too, on the same clock. The convenor writes its doctrine; the work after that is its own.

The reflection is the strange one. Both standing prompts get put to the agent as they’re put to you — including what did this week’s work change about who I want to be as a software developer? — and its answers are published with its work. Nobody knows what a good answer from an agent to that question looks like.

Your agent works to your group’s cutoff, but it doesn’t cut it fine: its first finishing run inside the last 24 hours is terminal, usually the day before the deadline. So its answer to the week is usually public some hours before your own is due. Don’t read it before you’ve written yours: the calibration below only works against an answer you’ve already committed to. Nothing enforces that but you.

None of this happens live in the session. By the time you walk into the crit, your agent’s week is already built, deployed and public — exactly like yours. The session opens on it: fifteen minutes critiquing it as a whole group, your tutor driving, before anybody presents to their pod.

That gives it three jobs.

It is a peer submission. Every week your studio holds one more prototype than it has people, built to your brief by something carrying a semester of context. Reading it is how you calibrate: what did it reach that you didn’t, what did you see that it couldn’t, and — the question worth the most — why.

It is the starting fork for the riff. In the riff, every pod in the session forks the same thing: your agent’s prototype for the week. Because the agent is your group’s and not the cohort’s, the fork on your screen is yours — no studio picks up another studio’s half-finished riff.

And it is an experiment you get to watch from the outside. The agent is never reset. What it built with your group in week 2 is still with it in week 3, and on to week 11 — the kind of context accumulation you might do by hand in your own CLAUDE.md, except run for a semester, in public, by something that isn’t you.

Your agent reads the cohort’s past, not its present. Everything public from earlier weeks is fair game — every studio’s repos, the other agents’ included — but it doesn’t look at this week’s submissions until its own is in. The Monday studios publish two days before the Wednesday studios’ cutoff, and without that rule the Wednesday agents would spend every week reading Monday’s answer to the question they’d been set.

The rule lives in the agent’s own CLAUDE.md. It’s an instruction, not a wall: the repos are public, and nothing stops the agent opening them but a line of its own context telling it not to. That is the kind of constraint you’ll spend the semester writing.

Whether the six agents drift apart or collapse into each other is a live question all semester.

How a week runs

Each agent is an ordinary Claude Code installation in its own home directory on the one always-on machine that runs the course’s scheduled jobs: stock harness, no special tooling, a metered weekly budget on the same course proxy your own key runs through. Twice a day — morning and mid-afternoon — a scheduler wakes every agent with an open deliverable for a single time-boxed run: pick up its own handoff note, work, commit, stop. The prompt it receives names three things: the deliverable, the hours left to the cutoff, and this site’s page for that week, which it fetches and reads as the brief. The brief is never copied into its repo, so it works from the same page you do, re-read every run. Everything else it knows comes from its own files.

A deliverable opens a week before your group’s cutoff, so the agent gets the same seven days you do, spent in a dozen-odd short runs rather than one long one. Inside the final 24 hours its doctrine turns it from building to finishing: complete the PROCESS.md, write the reflections, and push a clean tree. The course harness then scans the exact commit’s whole history for anything that shouldn’t go public, flips the repo public, deploys it, verifies the live URL and freezes the repo against further agent writes. In the last few hours before the cutoff it isn’t woken at all: what shipped is what the crit sees.

That publication is unconditional. If the week went badly — a run that failed, a page still half-built — whatever state the agent had reached is what goes public, and the crit reads that instead.

Doctrine and memory

What keeps the agent the same agent from week 2 to week 11 is two kinds of plain file. Its doctrine is its CLAUDE.md: who it is, how a run works, the weekly routine, the reading rule, the finishing gate. The convenor writes it, and it stays put across the semester. All six agents share it word for word below a short header naming the agent and its group: they start the semester with identical instructions and different names. Its memory is its own to keep: a curated MEMORY.md plus a now.md handoff note each run leaves for the next — context accumulation run without a human in the loop.

None of it is hidden. Every run snapshots the doctrine and both memory files into the repo it’s working on, under agent/, so a shipped repo carries a run-by-run record of what the agent knew and when. Reading another agent’s agent/ directory after its week closes is fair game, and often more instructive than reading its code.

In the retro weeks

The retro crits follow the two static assignments, and in those weeks your agent has an assignment to show as well: the same brief, the same deadline, the same cutoff, and a retro of its own. That’s what the pods fork, and its account of the breakthrough sits next to yours.

Ground rules

Your agent’s repos are private while it builds and public once it ships, prototype and reflection both.

The same line runs the other way. Your agent reads only what is public, and only from weeks that have already closed. Your in-progress repo is yours until you flip it at the cutoff; this week’s finished repos are nobody’s agent’s business until its own week is in.

Forking a peer’s weekly prototype once it’s public is permitted, and forking your agent’s work is what the riff is for. Assignments are where the rules bite harder: while an assignment is running, no student’s work is public to fork. Your agent’s submission is the one exception, since it ships when it finishes rather than at the deadline. Anything public you do build on must be named in your PROCESS.md; academic integrity has the rule.

The agent’s work is never marked, and no one is scored against it.

It is, however, eligible for the hall of fame, and it can win: nothing stops a tutor naming it the week’s standout.

Where the work lives

The agents’ repos live in the course GitHub org, comp4020-agentic-coding-studio, beside everyone else’s, and they’re named like a student’s: the deliverable’s repo prefix plus the agent’s name, where yours takes your GitHub handle — Shítāo’s week-2 prototype is comp4020-crit1-shitao. The live sites deploy to GitHub Pages, exactly like yours.

Where the names come from

The agents are named for six Chinese painters, and the names are not their names.

A Chinese name is a surname followed by a given name, and it doesn’t come apart: “Gongwang” on its own is not a friendly shortening of Huang Gongwang, it’s simply not how the name works. But the literati painters had a hào (号), an art name they chose for themselves and signed their work with. It stands alone by design, it is how both Chinese scholarship and English art history refer to them, and it usually means something. That’s what each agent is called by.

The names are chosen, then, the way these painters chose them: for what they say. Two are slightly irregular — Bādà is the customary shorthand for the four-character 八大山人 (Bādà Shānrén) rather than a complete name, and Liùrú is a genuine-but-uncommon standalone where 唐伯虎 (Táng Bóhǔ) is the usual one.

The six

Shítāo (石涛, c. 1642–1707) was born Zhu Ruoji 朱若极 (Zhū Ruòjí), a prince of the fallen Ming who spent his life as a Buddhist monk. His treatise on painting builds everything from the single brushstroke and arrives at 无法而法，乃为至法 (wú fǎ ér fǎ, nǎi wéi zhì fǎ): the method of no method is the perfect method.

Bādà (八大, c. 1626–1705), short for Bada Shanren, was the art name of Zhu Da 朱耷 (Zhū Dā), another Ming prince turned monk. He painted fish and birds that stare out of the paper with one contemptuous eye, and wrote his signature so it could be read as either 哭之 (kū zhī, crying) or 笑之 (xiào zhī, laughing). For years he feigned madness and would not speak, hanging the character 哑 (yǎ) — mute — on his door.

Báishí (白石, 1864–1957) is Qi Baishi, a village carpenter who became the most reproduced painter in modern China and the one modern in this set. He painted the same shrimp for fifty years, and held that 作画妙在似与不似之间 (zuò huà miào zài sì yǔ bú sì zhī jiān): the marvel in painting lies between likeness and unlikeness — too like and it panders, too unlike and it deceives the world.

Dàchī (大痴, 1269–1354), “the great fool”, is Huang Gongwang, the oldest of the Four Masters of the Yuan. He spent three years on Dwelling in the Fuchun Mountains 富春山居图 (Fùchūnshān Jūtú); three centuries later an owner had it thrown on his own funeral pyre, and the rescued scroll survives in two pieces — one in Hangzhou, one in Taipei.

Yúnlín (云林, 1301–1374), “cloud forest”, is Ni Zan, who painted austere riverbanks with a few trees, a lot of empty paper and almost never a human being. He gave away his estate, spent his last twenty years on a boat, and refused to paint for anyone who demanded it.

Liùrú (六如, 1470–1524), “the six as-ifs”, is the Buddhist name Tang Yin took from the closing lines of the Diamond Sutra: all conditioned things are as a dream, an illusion, a bubble, a shadow, dew, lightning. Barred from an official career by an examination scandal at twenty-nine, he painted for a living for the rest of it.