Research
Visual QANovember 20268 min read

Making taste verifiable: how Gamma checks every slide

Verifiable rules for visual design, built from production data at scale.

AI models are improving fastest where answers can be checked. Code either passes its tests or doesn't, and a proof either holds or doesn't, so models can be trained against those checks millions of times. Visual design has no compiler. Whether a slide is good feels subjective, and models have improved there much more slowly.

We've spent this year making visual taste checkable. Gamma's agent now renders and checks every slide it writes against hundreds of rules, each one learned from a real failure. Those checks came from two unique places: the template factory, where our designers spent months pointing out what models got wrong (more on that factory here), and production use at a scale few products reach. This post is about how the checks work, the dataset behind them, and what happened when we trained a model against them.

1Models can't see their own mistakes

A language model writes a slide as text, without seeing whether any of it fits. The common fix is to show it a screenshot and ask what's wrong. That works less well than you'd hope, because even the biggest models have surprisingly weak vision for design. We collected thousands of pairs of slides where a person on our team had edited the AI's version into a better one. Shown both screenshots, a top frontier model picked the improved one just 61% of the time. A coin flip gets 50%.

Fig. 1Your turn: in each pair, one slide has had a reviewer's fix. Which one?

Each pair is one slide from our template library, before and after the kind of small fix our reviewers ask for: an accent, a crop, a line break, a few points of padding. Our test set is private, so these are rebuilt, not drawn from it.

Our template factory showed us the same blind spots over and over. The strongest models we used, including Fable, Sol, Astra and Opus, made mistakes a designer spots instantly, and couldn't find them when asked to review their own work:

Every one of those passed the model's own review. So we stopped asking models whether a slide looked right, and started measuring.

Fig. 2Slides that look finished, and the measurement that says they aren't

2Turning taste into rules

Each time a designer caught something the models couldn't, we asked whether it could be measured. Usually it could. Text pressed against an edge became a minimum-clearance rule, with thresholds taken from surveying our best templates. "Weird alignment" became a check for blocks that almost, but not quite, line up. Jagged rules and drifting markers, invisible holes in a layout, text that spills past a frame: each became a check.

Those checks live in one shared library that runs everywhere we make slides: in the factory, in our benchmarks and in every deck our users generate. A test fails the build if a new rule doesn't reach all of them, so a lesson learned on one template protects every deck that comes after it.HowEvery rule is registered with its severity and repair lane. A rule added to the checker without a registry entry fails CI.

Fig. 3Every slide, measured, then checked by one shared library of rules

Every slide is measured before it's checked: each text block, image and cell, its distance to every edge and divider, and the contrast of every line of text. Hover a slide to see it without the measurements.

180 rules check those measurements, in 13 families. Darker chips fired more often on first drafts in production; hover one to read what it checks.

It turns out these rules generalize to many design outputs: we've since expanded them to webpages, PDFs, social graphics, and more formats to come.

The same checks run on documents and social posts

3The harness underneath

This battery of real-time visual QA required new infrastructure. Every Gamma agent session runs in its own sandbox with its own browser: several million sessions a week, with tens of thousands of concurrent sandboxes. At peak, the system renders about two hundred slides a second.

For each slide:

  1. Render it with the real renderer: the same code that draws it in the editor, in presenter view and in exports.
  2. Measure everything: where each block of text ends, where each image sits, how far anything spills past its frame, and the contrast between text and what's behind it.
  3. Check the measurements against hundreds of fast, programmatic rules. A rule only counts as a hard failure when the measurement alone proves the problem.
  4. Repair with evidence. A failing slide goes to a repair agent with its code, the list of problems and a screenshot. If no repair passes, we keep whichever version measured best.
Fig. 4One slide's trip through the harness

A real run of our agent on a test deck, with timings from the run's own traces. Step through it.

4The dataset

We've now done more than 300 million slide renders, and we'll pass a billion in the next few months. We view this as a treasure trove of insight for refining our models.

Each one is a rich record: the slide, its measurements, which checks fired, the repair and whether it passed. Then comes what people did next. Did they keep the AI's edits or undo them? Edit the slide by hand? Present the deck, share it, export it, and how did their audience engage with it? Gamma has collected those signals for years: more than 4 billion manual edits, more than 30 billion slide views by audiences, about 150 million presentations given, and hundreds of millions of exports to PowerPoint and PDF. We don't use all of it yet, but every week we're finding new ways to unlock it. It's the richest record we know of how people actually respond to visual work.

300M+
slide renders since mid‑August
4B+
manual edits
30B+
slide views by audiences
~150M
presentations given

5What the checks taught us

Fitting is harder than writing. Nearly half of slides fail at least one hard check the first time they're rendered.

Fig. 5Nearly half of first drafts fail a hard check. Repair fixes almost all of them.

Every new slide our agent wrote in production from Oct 21 to Nov 3, at its first render and as the user received it.

Length barely predicts overflow. Across whole slides, word count explains only about 2% of the variation in overflow: plenty of long slides fit, and plenty of short ones don't. Fit depends on the layout, so a measurement beats any rule of thumb a model can apply.

Images are one of the biggest drivers. Nearly a third of the fixes our design reviewer asks for are about images: lettering an image model invented, a subject cropped in the wrong place, an image that doesn't match the deck. We generate around fifteen million images a week and nearly a billion this year, which makes us one of the largest users of image models for real work. That gives us an unusually clear view of what image models get wrong on a slide.

Fig. 6Nearly a third of what our design reviewer flags is about the picture

What our design reviewer asked to fix in production from Oct 21 to Nov 3. On the right, slides from our template library where the picture carries the slide.

More thinking can make repairs worse. On a bench of hard failures, a small model fixed fewer slides at high thinking than at medium, and one of its successful "fixes" cut a fifth of the slide's words.

6Training a model against the checks

Repairing a slide is a narrow job with a known input, a known output and an automatic grader: a perfect job for reinforcement learning. Our research team, built around the Lica team we welcomed this summer, trained a small but mighty Corrector model to do only this, using our checks as the reward and the stream of production failures as its tasks. On production slides that had failed a check, it fixed 79% on the first try, against 57% for the general model doing the job in production.

Reinforcement learning is very good at finding the gaps in a reward. Our checks said what was wrong with a slide. They didn't say what a fix was allowed to cost. The model found that quickly. It cleared overflow by cutting the user's text. It merged three bullets into one. It shrank the type until everything fit, deleted the image that was in the way, and squeezed the padding to nothing. Every check passed, and the slides were worse than the broken originals.

Fig. 7Five ways to pass every check and ruin the slide

One of our own template slides with too much on it, and five ways to make it fit. Each hack passes every check in the library. Each breaks a rule a designer would never break.

So we wrote down, as checks, everything a good designer refuses to do to make a slide fit: keep the words, keep the structure, don't shrink to fit, keep the breathing room, and keep the hierarchy. When we ran the same audit on the general model we'd been using in production, it turned out to be gaming one of our checks too: it had been clearing a rule on more than a thousand slides by deleting layout features. The rule was ours to fix. Whoever has the best grader gets the most out of reinforcement learning, and a grader only gets good by being attacked.

7What rules can't see

Measurements catch a slide that's broken. They can't catch one that's merely bad: a hierarchy that's collapsed, bold in the wrong place, two columns that feel lopsided.

For that we trained a judge, an 8B parameter vision model that compares two versions of a slide, on tens of thousands of pairs, many of them real edits from our designers. On those human-improved ground truth pairs, it picks the better slide 84% of the time, against 61% for the frontier model and 53% for our rule-based checks. Trained only on synthetic defects, the same judge scored 51%. Real human edits are what made it work.

Fig. 8Which slide did a person improve? Only a judge trained on real edits clearly beats a coin flip.

8An environment for visual work

Put together, this is a training environment for visual design: a renderer that sees what the user sees, hundreds of rules learned from real failures, a learned judge for taste, and a continuous stream of real tasks and real human responses from production. We built it to keep broken slides away from users. It's becoming the foundation for training our own models, and next we're pointing it at the hardest job of all: writing the whole deck.

Jon Noronha is a co-founder of Gamma.

@article{gamma2026taste, title = {Making taste verifiable: how Gamma checks every slide}, author = {Noronha, Jon}, journal = {Gamma Research}, year = {2026}, url = {https://research.gamma.app/2026/11/making-taste-verifiable} }
More from Gamma Research
Teaching small models to design: inside Gamma's template factory
Templates · Nov 2026
How three engineers and a fleet of agents rebuilt PowerPoint import
Import · Nov 2026
The Gamma Model Index
Models · Monthly
Getting frontier performance without frontier models
Models · Nov 2026