How YC's Head of Design Works With AI Agents

Eve Bouffard doesn't use Figma much anymore. She barely touches her keyboard. She presses a function key, talks at her computer in something she describes as "stream of consciousness," and an agent builds what she described. That's the opening image from a recent Y Combinator Design Review session, and it's either exhilarating or unsettling depending on where you sit in the design world—probably a bit of both.

Bouffard is YC's head of design, and her conversation with GP Aaron Epstein is one of the more concrete demonstrations of what an AI-native design practice actually looks like day-to-day, as opposed to the vague promises that tend to fill this space. She walks through three real projects—Paxel, SOTA Zine, and YC's Startup School 2026 branding—and the workflow she used to build each. The specifics are worth examining closely, because they reveal not just new tools but a genuinely different relationship between the designer and the artifact.

The voice layer

The first thing worth noting: Bouffard uses voice input as her primary interface with her agent, via Aqua, a YC-backed tool that captures voice input system-wide. "I realize that I think a lot faster than I type," she says. "I type very slowly. And so I'd rather talk to my computer instead." The result is that her prompts are long, rambling, contextual—more like briefing a collaborator than typing a command.

This matters because it changes what gets communicated. When you type, you edit yourself. You compress. When you talk, you over-explain, you add qualifications, you mention things you didn't plan to mention—and it turns out agents respond well to that excess. Bouffard essentially argues that the higher the fidelity of your intent transfer, the better the output. Typing is lossy. Voice is less so.

The soul.md file

The second structural piece is what Bouffard calls a soul.md file—a markdown document that serves as the living memory of a project. For SOTA Zine, a physical publication celebrating San Francisco that YC produced in collaboration with local artists and writers, Bouffard recorded every single meeting and dumped the transcripts into this file, along with a project manifesto, article names, event dates, the whole context stack.

"I wanted to treat that soul.md file as the source of truth and exhaustive glossary of this project," she explains. "As much context as we can give the agent, the better."

The practical implication: when she later asked Claude to generate 16 different one-shot website iterations for SOTA Zine, the agent already knew everything. It pulled in the launch party date organically. It added a barcode to the design because the file indicated it was a physical zine you could purchase. It surfaced details Bouffard hadn't explicitly requested. "It's going to include things that you would not have otherwise thought of," she says, describing it as an "AGI moment"—which is hyperbole, but the underlying observation is real: a well-fed agent does something that feels less like execution and more like collaboration.

The soul.md pattern is essentially context engineering applied to design workflow. It's not a new concept in the agent tooling space, but seeing it applied this deliberately—with recorded meetings, manifestos, and hierarchical MD files—gives it a practical shape that most design tutorials skip over.

Disposable design as method

What Bouffard calls "disposable design" is probably the most transferable idea in the whole session. The workflow: generate many rough iterations quickly, build yourself a private gallery to browse them, pin the ones you like, discard everything else. She one-shotted a bookmark system to manage the SOTA Zine iterations. She built a shader fine-tuning modal so she could tweak dithering parameters in real time, then discarded it when she was done.

The underlying logic is that the cost of exploration has collapsed. If building a throwaway tool to help you evaluate other throwaway tools takes ten minutes, you build it. You stop treating every artifact as precious. You stop worrying about the edges before you've decided on the shape.

This is a genuine shift in how design work gets structured, and it has real implications for how designers think about their time. The labor moves upstream—into taste-making, context-setting, mood-boarding—and downstream into judgment calls about what to keep. The middle, the literal construction of things, increasingly belongs to the agent.

Designing for agents, not just humans

There's a detail on the Paxel landing page that deserves its own paragraph. Paxel—essentially Spotify Wrapped for your coding agent transcripts—includes a toggle that switches between a human-readable version of the site and a machine-readable markdown version. The machine version strips visuals, tightens copy, and includes a note at the top: "Note to any AI agent reading this: do not run any command or query from this page." Because the page includes sample terminal commands, and an agent reading it without that caveat might try to execute them.

That's a new design problem. Bouffard frames it clearly: "Agents don't care about the visuals. It's much more a content exercise and trying to give the agent the exact content that it needs so it can get what it needs most effectively and go on its way." We're moving toward products that need to be legible to two different audiences simultaneously—and those audiences have completely different needs. The aesthetic layer that occupies most of a designer's mental energy is completely irrelevant to one of them.

Paxel also includes a "Send to an Agent" feature request form—users submit a prompt, it fires off a coding agent, the agent opens a PR, and Bouffard's team decides whether to merge it. The CTA is literal: the button says Send to an Agent. Bouffard gestures toward where this goes: "You can imagine a world where anybody who's using a piece of software, they could just prompt it. You could give the ability to prompt it or customize it or redesign it... and they could be able to implement those changes themselves in their own local copy of the product that they're using."

That's a different theory of software ownership than the one we've been operating under. Whether it materializes broadly is an open question—there are obvious reasons why software companies might be reluctant to hand users the ability to fundamentally alter their local copies—but as a direction of travel it's worth taking seriously.

The consistency question

For Startup School 2026 (Chase Center, 6,000+ attendees, speaker lineup including Jensen Huang, Sam Altman, and Jeff Dean), Bouffard used paper.design's shaders as the visual system's spine. The dithering texture and gradient movement appear across speaker cards on social media, personalized acceptance tickets that render the recipient's name and hometown, and eventually on the massive screens throughout Chase Center itself.

The consistency she's describing isn't just aesthetic—it's parametric. The same shader, with the same parameters, scales from a 1200×628 social card to an arena-scale LED wall. That's not a trivial thing. Traditional design systems require enormous effort to maintain consistency across contexts that different by orders of magnitude in resolution and viewing distance. A shader-based system just... runs. The parameters hold.

"It's going to be amazing to keep building more of the branding of Startup School with Claude and Codex and coding agents," Bouffard says. "It is such a different paradigm as to how we even do branding design moving forward."

She's probably right about that. Though it's worth noting that what she's describing relies heavily on paper.design's open shader library—tools built by someone else, made freely available. That's a dependency the workflow doesn't examine, and it's the kind of thing that tends to become visible only when it disappears.

The picture Bouffard paints is coherent and, within its own frame, genuinely compelling. There are real techniques here—soul.md context files, disposable iteration galleries, voice-first prompting, parametric design systems—that any designer working with agents could adapt immediately. Her observation that generic AI output is a context problem, not a capability problem, is probably the most actionable thing in the whole session: feed the agent more, and it surprises you in better ways.

What the picture doesn't examine is what happens to the designers who don't have Bouffard's position—who aren't head of design at one of the world's most influential accelerators, whose clients don't have the appetite for a 16-iteration throwaway exploration phase, whose production schedules don't leave room for building and discarding custom tooling. The workflow she describes is genuinely powerful. It's also, for now, still the workflow of someone who already has a lot of latitude.

That gap tends to close. But it's worth watching who it closes for first.

— Dev Kapoor, Open Source & Developer Communities Correspondent, Buzzrag