
In short: our sprint review now builds itself. At the end of every sprint, a tool reads what the developers changed and turns it into a slide deck that marketing and other non-technical colleagues can follow. AI writes the words, code checks every claim against the real changes, and the before and after screenshots come from the product itself. Most weeks, the only thing left to do is click publish. Result: about five hours of work per sprint became about 15 minutes.
The problem
Most of what a development team does in a week is invisible to the people who use the product.
A sprint review should fix that: at the end of every sprint, the team shows what changed. Most teams work in two-week sprints. We work in one-week sprints, so for us it's every week. For developers it's an easy meeting. For marketing and everyone else without a technical background, it often isn't. A change called "optimize count queries on overview" means nothing to them, and a list of tickets doesn't say what got better.
So someone has to translate. Usually that's the developer who presents, scrolling through a week of changes and building slides by hand. Done properly, that's easily half a day: reading the changes, picking the topics, taking before and after screenshots, writing it in plain words and making it look good. It's the job that gets skipped in a busy week, which is exactly the week with the most to show.
The goal: a presentation that's ready before anyone opens it, in the words the audience uses, and that never claims something that didn't happen.
What it makes: one page, ready to present
The output is a single web page that works as a slide deck. Arrow keys to browse, a presenter window with notes and a timer, and it prints to PDF for anyone who missed the meeting. A typical review has about 15 slides:
This sprint: a few cards that sum up the week.
What we gain: the changes grouped by what they bring, like faster work, less manual work or less risk.
One slide per theme: what changes for the user and three or four points. How many themes a review can hold is a setting.
Before and after: pictures of the screens that actually changed, the new one wiping in over the old.
Usage and milestones: how the product was used this week against last week, and where the roadmap stands.
Under the hood: the technical work that matters but isn't visible, on one slide so it doesn't crowd the rest.
Every theme has speaker notes: what to open, what to point at, how to explain it. The audience reads plain words, and the presenter gets a script.

A theme slide from the demo review. One line on what changes for the user, then the points, each traced to a real change.
One sprint, start to finish
The examples are from a demo review: the output of a real run, rewritten for a fictional bike-shop chain, Northside Cycles, and its app, Spoke. The real reviews are for an internal platform, so the demo keeps its data out of this post.
On sprint review day. A scheduled job starts for every team that has the review switched on, and skips a day that already has one. An admin can also press Generate. The sprint length is a setting: a team on two-week sprints changes it once, and the review covers two weeks from then on.
Reading the sprint. The job reads the code history of the version that's live: every change in the sprint, each with its description and the files it touched. Changes to tests, docs or tooling are kept apart. They can show up under the hood, but they can never carry a theme.
Writing. The first AI gets that history and fills in everything a slide needs: the summary, the themes, the points, a caption per changed screen and the speaker notes. Code and a second AI then check all of it, more on both below.
Building the page. Code puts the slides together with the team's logo and color, the screenshots, the usage numbers and the milestones. The result is saved as a draft. Nothing is published.
Before the meeting. In most cases the presenter reads it through and clicks publish, without changing a thing. When something does need a tweak, they can fix a word, reorder the themes or pick a desktop or phone picture per theme. For people outside the team, a share link works without an account.
The AI writes, code checks
Early versions gave the AI more say, and it showed. Sometimes it picked the wrong screenshot for a theme, sometimes the output was just odd. Let an AI build the whole review and it starts making things up.
The most important design decision: the AI only writes words. It never builds the page, never counts anything and never picks a picture on its own.
Why: a sprint review is a report of facts. If a slide says a screen got faster and it didn't, or shows a feature that never shipped, the meeting loses its point, and nobody trusts next week's review either. AI is great at turning "optimize count queries" into "the screen loads faster". It shouldn't be the one deciding what happened.

The AI only writes words. Code and a person handle the rest.
So every line the AI writes goes through code before anyone sees it:
Every point names its source. The AI has to say which change each point comes from. A point that names no real change is dropped. A point that only comes from a test or tooling change moves under the hood.
Short and plain, by rule. At most 16 words per point, 25 for what changes for the user and 70 for the speaker notes. No exclamation marks, no emoji.
No developer leftovers. Ticket numbers, pull request numbers and code hashes are stripped.
Numbers come from code. Usage per week is counted from the product's own data, and only what a person started counts, never names. Milestones come from the roadmap file.
Pictures from a fixed list. The AI can only pick a screen from the screenshots that exist. Code decides which theme gets which picture: at most four, never the same one twice.
Change descriptions are data, not instructions. They're written by people and go in marked as untrusted text, so a line like "ignore your rules" in a change is just text.
A second AI that reads like a marketer
Developers are bad judges of whether something is clear, and so is the AI that just wrote it. Both know too much.
So a second AI call gets only the slide text. No code history, no context, nothing it could use to fill a gap. It reads like someone from marketing and lists every spot where that reader would get stuck: a word they wouldn't know, a point that doesn't say what changes for them.
It doesn't rewrite anything itself. Think of it as a safety net: the code checks already make sure every slide is correct, and this catches the occasional line that's correct but still unclear.
Screenshots without customer data
Before and after pictures make a review, but screenshots of a live product are full of real customers. So the sprint review tool doesn't take screenshots itself. It reuses the ones the product already makes: its automated tests take a picture of every main screen, on desktop and on phone, filled with made-up test data.
So the generator compares the test pictures from the start of the sprint with those from the end. A pixel comparison finds the screens that really changed. It ignores the side menu and the top bar, so one new menu item doesn't mark every screen as changed. On desktop it zooms in on where the change starts, so the slide shows the part that matters.

Before and after, found by comparing the test pictures. The new screen wipes in over the old one when the slide opens.
What we ran into
Only what's live counts. The history comes from the server's own copy of the code, so a review on production only shows work that has been merged and deployed. That's on purpose: the review never shows something people can't use yet.
The word that kept coming back. The AI kept picking a word for notes that the team never uses. Now a small list of fixed replacements in code makes sure the slides use the team's own words.
A prompt that never needs editing. The prompt holds principles and examples, nothing about one particular sprint. All the variation comes from the history, so nobody has to touch it before a sprint review.
The pattern behind all of these: whatever code can do, code does. The AI only gets the part where being slightly different each week is fine.
The stack, and why
Laravel with a queued job for the run and a scheduled command for sprint review day. It's what the platform already runs on.
Claude (Anthropic), always the latest model, for both AI calls, through a fixed form of fields rather than free text, so code can check every field. The model, a backup model and the effort level are a setting, not code.
Git as the only source: the change history and the roadmap file of the version that's live.
Playwright visual tests for the screenshots, the same ones that guard the design.
Vue for the list, the editor and the check log.
One self-contained HTML page per review, with no outside fonts, scripts or images, so it opens anywhere and still works next year.
Results
Per sprint | Before | After |
|---|---|---|
Reading the changes and picking topics | about 1 hour | done before anyone opens it |
Before and after screenshots | about 1 hour, by hand | changed screens found and cropped automatically |
Writing it in plain words | about 1 hour | a draft, checked by code and a second reader |
Making it look good | 1 to 2 hours of slide building | one consistent page in the team's colors |
Speaker notes, usage and milestones | about 30 minutes | on the slides already |
Every claim traceable to a change | no | yes, or it's dropped |
Total | about 5 hours, easily a day in a busy week | about 15 minutes of checking |
Altogether, an estimated four to five hours back every sprint. With our one-week sprints, that's roughly 200 hours a year. And the review no longer gets skipped in a busy week.
"I finally understand what the developers did."
If you're building something similar
Give the AI the one job it's best at, and nothing else.
Here that job is translation: from how developers describe their work to how everyone else would. Everything that's a fact stays with code: what changed, how much it was used, which screen moved. Every claim carries a reference that code can check, so a wrong one is dropped instead of presented.
Then let a second AI read the result the way your audience would, because the writer can't spot its own jargon. And keep a person in charge of the last step. Most weeks that's a single click on publish, but they're the one presenting it, so it should be their call.
