Ask someone to describe the look they want for their next presentation, and most of them can't. Show them a hundred and they'll point at one in seconds. Visual taste is something people shop for, not something they specify. That’s why most human design collaborations start with a mood board, not a written prompt.
That’s why nearly every deck made by the agent in Gamma 5 starts from a template, and why we’ve invested in a pipeline for building out thousands of diverse templates to anchor our visual generation. This might seem like a contradiction, since Gamma was the original AI slide generator. Why would you need templates when AI can make a fresh deck from scratch?
Every frontier model has tells that give it away, as anyone who’s sat through a few too many Claude presentations can tell. We faced this challenge earlier this year: as Gamma became widely adopted, the “Gamma smell” went from an asset to a liability. The core issue is that people want AI-generated decks that don’t look like they were generated with AI. In this sense visual design is almost like fashion, with an ever-shifting set of standards and no stable equilibrium. This means we can’t defer to models for visual taste: we have to own it, and continuously evolve it ahead of the curve.
Templates also let a small model design like a large one. We run our most capable models for hours on each template, at $50 to $100 apiece. After that, a small, fast model can adapt the template to anyone's content in about a minute for around 10 cents. In effect, this is a form of distillation: what the big model knows about design ends up in the library, where every small model can use it. The same trick works for image models. A slow image model paints the look, and we turn that look into a coded template that renders instantly.
And because a template is a real, structured Gamma presentation, the look stays editable: the person or the AI can change any element afterward. For the growing number of companies running Gamma across their teams, that's also how brand rules, consistency and predictable results show up in every deck.
So we treat the library itself as one of our most important assets. Browse it at gamma.app/templates.
Templates from our library, each paging through a few of its slides. Every one opens its page on Gamma.
1Applying software factories to design
In coding, the term “software factory” has emerged to describe a fleet of agents operating autonomously with minimal human engagement. Software factories work when code is verifiable, relying on automated tests and occasional steering but little review of the actual code. We'd already seen this work firsthand: in August, a fleet of agents rebuilt our PowerPoint importer in record time, compressing a year of work into just a few weeks (How three engineers and a fleet of agents rebuilt PowerPoint import).
The template library needed the same thing. In July we started with 16 golden example templates. Today it holds thousands of templates and variations, almost all of them built by a factory of agents steered by people on our design and content teams. We’ve expanded its scope over time: from presentations to documents to social graphics and webpages, and from internal use to custom templates tailored for each customer’s brand.
2How the factory works
- A person writes a brief: who the deck is for, what story it tells, how it should feel.
- An image model paints the target. One of several image models produces sheets showing what the finished template should look like. They become the creator's steering wheel, the builders' visual spec and the critics' answer key.
- A frontier model builds it. It turns the painted look into a real, editable template, plans every slide, and a fleet of writers builds all 20–30 slides in parallel, with image models creating the artwork.
- Every slide is rendered and checked by the same measured checks our product runs on users' decks.
- Adversarial critics review it. A dozen critics, each with one specialty (typography, writing, imagery, polish, robustness, cultural fit and more), see only the brief, the target and the rendered slides. They never see the builder's reasoning or code, so they can't be talked into its choices. Judgments of taste are made three times, and the majority wins.
- Steps 3 to 5 repeat, for hours. The builder revises against the critics' ranked findings, and the loop runs again until the template passes or a person needs to weigh in.
- A fill test pours in content the template was never designed for: too sparse, too dense, no images, a different color scheme. It still has to fit and still has to look intended.
- A person with taste has the last word. The creator reviews the result in Gamma, sends notes, and the loop picks up from there.
Slide 24 of Beachhead, a go-to-market template in our library, at each stage of the factory. Open any stage to see it full size.
3Running models for hours
Each template is a long-running job, and we use Devin, Cognition's autonomous coding agent, to run it. Every ticket starts a Devin session that launches our own agent harness inside it, runs the build, the renders and the critic rounds, and reports back to the creator in the ticket. A typical template takes two to four hours from brief to finished proof. The record of the whole session, with all the intermediate stages and critiques, is stored for future training.
That taught us something about creative work with AI: give a model time and a loop, and the output gets much better. We were surprised to see outputs continue to improve even after 4 or 5 rounds of iteration, especially with adversarial critics running different models probing for different weaknesses and identifying new opportunities to elevate the craft.
4People with taste in the loop
Agents do the building, and people decide what good looks like. Designers and writers on our team steer runs throughout: in two weeks of August alone, they sent more than 460 notes into the factory. Some templates start with a person's own design, which then goes through the same critics and checks. The factory holds human work to the same bar, and it has caught a truncated title and an unreadable label in our designers' own decks too.
Every week, we fed these human steers back into the factory itself: recurring issues became rendering fixes, prompt updates, or new AI critics to catch new classes of failure. By running this loop, we found that the number of human interventions steadily fell, from 10-15 needed per deck in July to full autonomy by October, with most templates needing no human intervention at all.
5What we learned
Models can't see their own mistakes. The builders we used, including Fable, Sol, Astra and Opus, repeatedly made errors a designer spots instantly, and couldn't see them when asked: faint gray hairlines that vanish on a normal monitor, a rotated headline clipped mid-word, 6-point white labels inside a bar chart, a "1" in a display font that made "41M" read as "4IM." One blue measured 4.75:1, comfortably past the web-accessibility contrast standard, and our designer still couldn't read it. We turned each of these into an automatic check, and those checks now run on every deck our users make (more in Making taste verifiable: how Gamma checks every slide).
Different models have different strengths. Over four months we've built with Fable, Sol, Astra and Opus, and painted with several image models. In a blind bake-off, our designers found one model bolder with layouts and another stronger with text. One builder was a quarter of the cost of the others for similar quality. Today, we mainly use GPT Image 2.6 as the designer, Opus 5.5 as the writer, and GPT-6.1 Sol as the critic. This adversarial approach, where competing models review and refine each other’s work, seems to work much better than sticking within one model family.
Adversarial critics beat a model checking its own work. A model reviewing its own output tends to defend its choices. Critics that see only the result, each looking for one kind of problem, are much harder to satisfy, and much more useful. They also help break out of the strong house visual style that each new model is naturally attracted to.
Templates are fashion. Every model has a default style, and what reads as "AI slop" keeps changing: this year's fresh look is next year's tell. The factory caps how often any one look appears, and we regularly rebuild and retire templates as tastes move. That's why the library has to be a continuous factory, not a static collection.
Our agent wrote the same brief, with the same numbers, on six templates from our library, using small models. Pick the one you'd present.
Critics breed clones. When a critic prescribed a specific fix ("make it a staggered layout"), that fix spread until it became the new cliché. Our critics name the problem, never the solution. And we found that this was another benefit of a library: it let us measure and enforce visual variety, by letting each new generation steer against the census of the library so far.
A template has to be about something. The best templates are one presenter's real presentation, with a story and a signature look that repeats from slide to slide. Robustness comes from the fill test, not from authoring every possible variant.
6The library as training data
The factory keeps a record of everything it does: thousands of complete design sessions, tens of thousands of versions of individual slides, and hundreds of cases where a person took an AI-made slide and improved it, or rejected an AI output entirely.
The human edits taught a judge taste. The model we use to compare slides learned from people improving AI-made slides. On those improvements, it picks the better slide 84% of the time. A top frontier model, judging zero-shot, manages 61%.
Live usage captures demand. With millions of users, we have enough data to measure which templates get chosen for which topics, and how well users actually rate them. This allows us to cull weak templates, multiply good ones, and find gaps in the library where no appropriate template exists. We then automatically feed this back into the factory, so the system learns how to satisfy demand over time.
The templates are a stage for training a writer. Our research team is training an open model to write whole decks, fed by the library and by the live record of how templates get adapted to real content and then edited over time. In a few months, we may not need all these templates anymore: they’ll remain as a browsing tool for users, but their visual range will be baked into the model itself.
Jon Noronha is a co-founder of Gamma.