Where things stand.
The August update was about a shift: design still lives in Figma, but it no longer stops there. Our designers work in the repository, coding agents carry the labor, and GitHub is where the work lives. This update is about what that loop produced over the summer, with the numbers attached.
Three things shipped. A presentation tool we now send every deck from. A discovery engine that turns a pile of interview transcripts into findings you can trace back to the sentence someone actually said. And the small daily paint game from the last update grew up, got a sibling, and got a name for the whole family. All of it came out of the same studio, on the same loop, with no engineering department appearing in the meantime.
Decks that are websites.
We send a lot of decks. Every one of them used to be a PDF pretending to be alive: a screenshot of a prototype, a screenshot of a site, a flat picture of a thing that moves. So we built a presentation tool where every deck is a URL. A slide can hold the real prototype, the staging site, or another deck, running. Send someone a link and they land on the exact slide, in any browser, with no viewer account.
It started with a hard rule borrowed from Snacks Sites: templates with slots, so the design intent is protected by the system rather than by a style guide someone has to remember. Then real decks pushed back. Importing a client's PowerPoint into our templates looked worse and lied about the original, so imports are now faithful to the deck they came from, and the tool earns its way in afterwards. Freeform is a step you take on purpose, never the starting point.
Since August it grew the parts a presentation tool needs to replace the one you already use. Two people can edit the same slide at once. Comments work the way they do in Figma: pin a spot, start a thread, resolve it. Speaker notes live in their own locked table and show up on your phone, which doubles as a presenter console with the next slide, a clock, and a timer. Share links can be tracked per person, so you know who opened what. PowerPoint files import with their fonts and layouts intact.
It is live at slides.snacks.design. Anyone can open a deck. Making one is by invite while we walk the outsider experience by hand, and the plan is unchanged: a free public tool, where outside users get the same editing we use, never a lesser tier.
Since August: 61 pull requests merged and 388 commits, by one designer working with coding agents, with a plan file that gets rewritten in the same pull request as the work. That file, not memory, is the product's memory.
A discovery engine with receipts.
A discovery engagement produces a pile: interview transcripts, sync notes, design audits, competitive and feasibility notes. Somewhere between that pile and the brief, the trail goes cold. A finding gets summarized, the summary gets summarized, and by the time a decision is made, nobody can point to who said the thing that drove it.
So we built a pipeline and a workspace that keep the receipts. Raw material goes in. Out come typed findings, each pinned to the exact span of text it came from, then opportunity themes, decision records, and briefs. A decision record is a real record: the options considered, the criteria, the evidence for and against, what was chosen. Every theme, brief, and decision cites finding IDs, and the demo move that lands every time is drilling from a decision down to the verbatim sentence a real person said.
The interesting part is what the system refuses to do. Before any of it existed we wrote down five rules, each one enforced in code and covered by tests, because a privacy promise that lives in a prompt is not a promise.
One router
A single policy module picks every model. Internal client material can only route to models on studio hardware. There is no second code path to forget about.
Scrubbed before it leaves
Names and identifiers become tokens before synthesis, and the cloud client only accepts payloads the scrubber has sealed. A test forges a payload to make sure it can't be fooled.
Verbatim or refused
A finding's quote must be an exact substring of its source, checked on write and again by a database trigger. No paraphrase gets stored as evidence.
Cite or fail
Themes, decisions, and briefs must cite the findings they rest on. Zero citations is a validation failure, not a style note.
Config, not code
A new engagement is a new YAML file. Client names, folders, and vocabularies never appear in the codebase.
On the first real corpus the gate refused 14 of the first 18 quotes, and the tempting fix was to loosen it. The actual bug was humbler: models paraphrase whitespace, not words, so a line break in a PDF became a space in the quote. The gate now tolerates whitespace drift only, stores the exact original span, and still refuses word changes. It turns away dozens of invented quotes every run. That is not friction. That is the product working.
- Raw materialTranscripts, sync notes, a Slack channel, design audits, video. Local models only.
- Typed findingKind, salience, and a quote that must be an exact substring of its chunk, checked on write and again by a trigger.
- ScrubEverything is scrubbed before synthesis; nothing leaves the machine with names on it.
- SynthesisFrontier models on scrubbed text only. Themes, decisions, and briefs each cite finding ids; zero citations fails.
- Back on the machineThe names come back client-side, and our team takes the cited result into artifact generation.
It can also read a contract and pin obligations and deadlines to verbatim clauses, framed strictly as preparation for real lawyers, never a substitute for them.
We built the portal the way it makes us work: coding agents carried the labor against a running decision log, and every non-obvious call got written down when it was made. Three entries worth repeating.
Reframed on day two
The inherited brief said app-store-review aggregation. The client's real material said discovery. We rebuilt the schema around typed findings and made reviews one optional adapter. The narrow thing we almost built would have worked and been useless.
Overruled by arithmetic
A resynthesis returned two themes across 239 findings and reported success. The arithmetic said otherwise, the prompt gained a coverage duty, and the next pass produced eight themes citing 411 findings. Models don't get to grade their own homework.
Outgrown by the corpus
Chat sent the whole corpus to the local model until the corpus quietly outgrew the model's context window. The fix selects the most relevant slice and says so in its answer. Next time we design for that growth on day one.
AI carried the labor. It never got to make the calls.From the decision log
Status: internal v1, in daily use on a live engagement. It went from a blank repository to a team beta in eight days. Today it holds 653 findings from 53 documents, clustered into eight opportunity themes, next to a trail of 28 decisions lifted from the documents, a cited risk register, and chat over the whole corpus that answers with citations. 145 automated tests cover the pipeline, invariants included, and the workspace app added zero runtime dependencies. There are no screenshots here on purpose. It is full of real client conversations. A client-facing view is a later milestone, and a deliberately gated one: everything defaults to internal, and nothing about a client's own organization ever publishes itself.
The calm one grew up.
In August, Swirl was one line on the scorecard: a calming daily paint game with real pigment physics, live on the web the day it was an idea. Every day there is one color with a name. You squeeze tubes to pour pigment, swirl it with your finger, and the mixing is what reveals the color you actually made. Three serves a day, everyone gets the same puzzle, no fail state. It was built to be the opposite end of the dial from Snacks Trivia: something to exhale into.
What changed since then is around the game rather than inside it. Swirl and Trivia now share one Snacks account: sign in to one and you are signed in to the other, with a single sign-out for both. Each game carries a small link to its sibling. And the family got a name, Snacks Arcade, which is where the next cabinets will go. The one on the bench now is a party mode: the TV is the stage and phones are the controllers.
The paint itself is the thing we are proudest of. It is a real fluid simulation, not an animation of one, and it is why the game feels like putting your hand in something.
Play it at swirl.snacks.design, and Trivia at trivia.snacks.design. 109 commits since August, most of them small.
The honest scorecard, continued.
The plan file is the product's memory. Every one of these projects keeps a living plan and a decision log in the repository, rewritten in the same commit as the work. When a teammate or an agent picks the project up cold, that file is the difference between continuing and re-deriving.
A green check is not a working product. We learned this more than once this summer: tests passed while the thing was broken on a real phone, and a screenshot looked fine while the page underneath had changed. So the same checks now run against the live site after a deploy, and a phone in a real hand gets the final say.
Import faithfully or not at all. Our first instinct with a client's deck was to reseat it into our templates. It looked worse and misrepresented their work. Faithful first, then improve, is the rule now, and it generalizes: the tool has to earn the right to change what it was handed.
Local first for anything sensitive. The discovery engine's most important design decision was which model gets to read what. Raw client conversations stay on the machine. That constraint shaped everything downstream, and it was cheaper to build in than to bolt on.
Guardrails beat guidelines, and now they run in the build. Even this website: every deploy runs a checker that refuses to publish a page missing its pieces, and the nav is generated from one canonical copy instead of being hand-edited on fifteen pages. The constraints that hold are the ones the system enforces.
The numbers. 588 commits across the three projects since the first of August. 61 merged pull requests on Slides alone. One discovery engine from zero to daily use in under two weeks. Every one of those numbers is in a git log you could read.
Questions we'd expect you to ask.
Can I use Snacks Slides?
You can open any deck someone sends you today, no account needed. Making decks is by invite while we finish the outside-the-studio experience. When it opens up, it will be free, and outside users get exactly the tools we use.
Is the discovery engine something clients get?
Not yet, on purpose. It is an internal instrument first, so we can be candid inside it. A client-facing view is a later milestone, and it will be publish-explicit: nothing is visible to a client until a person deliberately makes it so.
Why does a design studio keep making games?
Because they are where we try things with no client on the line. Real physics in a browser, shared accounts across apps, phones as controllers for a TV. Everything we learn there shows up in client work a few weeks later, already de-risked.
Is any of this fed into AI models?
No. The answer from August still holds. Client work lives in private repositories and under terms that keep it out of training. The discovery engine goes further: raw client material never leaves the machine unscrubbed at all.
Previous update: August 2026, Figma is still where design lives. It's just no longer where it stops. All updates live at Snacks Labs.