Session 3 of 8

Session 3: Agile Sprint Two, Review, Design & Your First Skill

Two sessions ago this was a one-shot. Last session it grew a backlog, a quality bar, and a properly shipped slice. This session is a full second sprint: review what shipped, re-skin the product like a designer, deliver a slice that feeds on live data, and end by looking back the way professionals do. Then, at close, the course turns.

Part 1: Sprint review: the demo (~20 min)

A sprint ends by showing, so show: give a 5-minute demo of the live site. Your tutor plays interested-but-busy stakeholder, because every demo you ever give will be to one of those. In Scrum this meeting is the sprint review: not a performance, an inspection, what shipped, what didn't, what the product taught you.

Look at the board while you're at it: what you committed to last session versus what actually reached Done. That gap (in either direction) is data, professionals call the pace it reveals velocity, and it's how the next sprint gets sized honestly. Your sprints are sessions; at work they're usually weeks; the arithmetic is the same.

Then two touches that make the product shareable:

A README for the repo: what it is, who it's for, the live link, one screenshot. (Ask Claude to draft it; make it sound like you.)
An accessibility pass: "check this page for accessibility basics, colour contrast, alt text, keyboard use, and fix what you find." If someone can't read or use your page, it isn't shipped for them.

Part 2: Design, sprint-style (~25 min)

The product works; now make it look decided. Agile designs fast and picks:

/design-shotgun

It generates several complete design variants and opens a comparison board. React honestly, pick one, note what you liked from the losers (onto the backlog, they're ideas, not losses). Then:

/design-html

turns the winner into production-quality HTML and CSS, the real skeleton your product wears from this session on. Ship it through the loop: /qa, /land-and-deploy, /canary. A restyle is a slice like any other, and the Definition of Done doesn't care how pretty the commit is.

Part 3: A slice that feeds on live data (~40 min)

New trick for this sprint: software that feeds on a live web page. Pick a page you actually check, the supermarket offers, your society's events page, the library's opening hours, ideally one your product could use, or one worth a page of its own on your site.

First, if the page needs you to be logged in, run /setup-browser-cookies, it copies your real browser's logins into the agent's browser. (Your tutor will talk through what that means before you run it.)
Then:

/scrape [the page's address], pull out [the thing you care about: offers and prices / events and dates / hours]

While it runs, notice the agent driving a real browser, that's /browse working under the hood, the same machinery the QA robot has been using right through the stretch.
Ask Claude to build a clean page from the scraped data, a personal dashboard, living in your product's repo. Break-test it. Ship it through the loop.
Now the magic:

/skillify

That takes the scrape you just did and turns it into a permanent command, from now on, one word refreshes your dashboard, forever.

Stop and look at what just happened. A skill is a markdown document that teaches the agent a repeatable workflow, and you just created one without writing it. The tools of the trade are documents; every /command you've run in this stretch is a well-written file. That's the demystification of the session: you can read them, and one day soon you'll write them.

Part 4: The retrospective (~20 min)

Sprints end twice: the review inspected the product; the retrospective inspects the process. Run:

/retro

With two sprints behind you: what went well (name it or you won't repeat it), what was harder than it should have been (patterns, not incidents), what surprised you (surprises are where your model of the world was wrong, the most valuable list in the room). /learn banks it, so next sprint starts smarter than this one did. In Scrum this is the sprint retrospective, and teams that skip it stay exactly as good as they are forever.

Part 5: The turn (~10 min)

Commit, push, /context-save, the agile rhythm is yours now.

Now step back. In three sessions, agile grew a one-page one-shot into a designed, tested, live product, one slice at a time, learning between slices, never deciding more than the next session needed. That's the right way to build when the product is small and the cost of changing your mind is low.

The next session's project is neither. An app on your phone, a web page in everyone's browser, and a shared database underneath them, three platforms that must agree with each other before anyone builds anything, because a wrong guess in the foundations costs weeks, not hours. You can't slice your way out of that. The next session you meet waterfall, decide everything, then build exactly that, and the project it exists for: the capstone.

What you just learned without noticing

The full Scrum ceremony set, review, velocity, retrospective, plus automation: you found a repetitive task and turned it into a one-word command, which is the entire reason software exists. And design by selection: generating options cheaply and choosing, which is how real studios work too.