COMP4020: the story so far

31 Mar 26

comp4020teaching

I’ve written eight posts now about a course that doesn’t start until July, and it occurs to me that someone stumbling onto one of the later entries might reasonably wonder what on earth I’m on about. So here’s the quick version.

COMP4020/8020 Agentic Coding Studio is a new ANU course for Semester 2, 2026. The pitch: LLM-based coding agents (e.g. Claude Code) are genuinely powerful for web development, so let’s teach students to use them well, not by lecturing about prompting techniques, but by having them build and deploy multiple working web prototypes over a semester. The course trains judgement: when producing code is cheap, knowing whether it’s worth producing is the whole game.

The distinctive design choice, and the thing I’m most excited about, is borrowing the studio crit model from art school. Each week follows the same cycle:

1. students receive a provocation (an open-ended brief)
2. they build a working web prototype before their next studio session
3. in the session (~20 students per group), everyone interacts with each other’s running apps, followed by a tutor-facilitated discussion

The crit covers both the product and the agentic process that produced it. How did you use the agent? Where did you have to intervene? What did you learn about working this way?

I ran a similar model for years in the ANU Laptop Ensemble course. Swap “web prototype” for “musical instrument” and “agentic workflow” for “sonic palette” and you’re most of the way there.

The crits need scaffolding, though, because Computing students aren’t used to ripping each other’s work apart the way art students are. So each week students answer three questions in 280-character “skeet” format: why this? (not “what does it do”—we can see that—but what were you going for?); what made it better? (which feedback loops, whether agent, human, or community, actually moved you forward?); and any good? (the hardest one and the most important: quality judgement, taste, and where you’d take it next). The constraint forces clarity: if you can’t compress your reflection into 280 characters, you probably haven’t found the actual insight yet. The skeets follow a staged visibility model (private until your crit, group-visible during, fully open after) to prevent anchoring.

The technical setup underpins the whole thing, and it’s designed so that students can let agents run freely without risk. Each week, they work in a fresh, isolated cloud VM (something like a Fly.io Sprite)—nothing personal on it, easy to snapshot, easy to tear down. They run Claude Code in YOLO mode with no approval prompts, push their code to a class GitLab server where CI smoke checks verify the basics, and every prototype ends up live on the open web by default. Peers don’t review each other’s code—they use each other’s running apps.

This ties into the course’s commitment to radical openness: students can see each other’s source repos, clone them, poke around, and remix each other’s work. One of the weekly provocations will probably require exactly that—take someone else’s previous prototype and build on it. The idea is that openness accelerates learning in the same way it does in open source: you get better faster when you can see how other people solved the same problem.

On theory, honestly, nobody really knows the right way to do agentic coding yet. I surveyed the emerging landscape—Regehr’s “zero degrees of freedom”, Harper Reed’s spec-driven development, Jesse Vincent’s Superpowers framework, the Deer Valley retreat consensus, Geoffrey Huntley’s Ralph Loop—and the picture is of a field still finding its footing. Part of what excites me about COMP4020 is that it’s a distributed experiment: 100–200 students road-testing these nascent theories and reporting back on what actually works.

There’s still plenty I’m wrestling with. Tool access is the most immediate: getting ~200 students onto frontier coding agents is a genuine logistics problem, and neither sponsored seats from Anthropic (the ideal) nor self-hosting open-weight models via vLLM (the fallback) is straightforward at this scale. Then there’s the question of the studio agent: whether to actually enrol a persistent AI agent as a course participant, building prototypes, writing skeets, observing patterns across the cohort. The question mark in that post’s title is load-bearing; the pedagogical possibilities are genuinely interesting (a baseline and a pattern observer at scale) but the “dead classroom” risk is real. Assessing taste at scale is another live concern: the course’s core thesis is that judgement and taste are the skills that matter most when code generation is cheap, but how do you actually assess that fairly across ~200 students? The weekly skeets and studio crits give tutors a lot to work with, but it’s still qualitative assessment of a quality that’s hard to define. And there’s the open question of whether the crit model transfers from art school to CS at all. I think it will, because my colleague Charles Martin has scaled the studio crit model to large cohorts in his Sound and Music Computing course (formerly the ANU Laptop Ensemble), but CS students have never done anything like it and it’s an open experiment.

If you want the full picture, here’s the reading order for the series so far:

1. Rapid Prototyping for the Web—the founding post, course description and learning outcomes
2. Sharp tools—the tool access problem
3. The core mechanic—the weekly loop and studio crit model
4. Safety, YOLO, and the open web—cloud VMs and infrastructure
5. Radical openness—sharing source code, deployed apps, and remixing each other’s work
6. The weekly questions—reflective practice and skeets
7. What’s the theory here?—a survey of emerging agentic coding theories
8. Agents in the classroom?—the studio agent idea

The course starts in July. More posts to come as I figure out the rest.

@online{swift2026comp4020TheStorySoFar,
  author = {Ben Swift},
  title = {COMP4020: the story so far},
  url = {https://benswift.me/blog/2026/03/31/comp4020-the-story-so-far/},
  year = {2026},
  month = {03},
  note = {AT-URI: at://did:plc:tevykrhi4kibtsipzci76d76/site.standard.document/2026-03-31-comp4020-the-story-so-far},
}