OpenAI Design: Models Over Pixels
Ian Silber explains how OpenAI designers treat AI models as the core product, prototype with code over Figma, and build reusable primitives around chat interfaces.
Research-Led Design Shifts Focus to Model Capabilities
Ian Silber, OpenAI's Head of Product Design, describes joining from a gaming startup amid GPT-4's release, bringing a team of eight ex-Instagram colleagues. OpenAI's research-lab origins create a mission-driven environment where progress accelerates daily. "From day one, it was just such a different place," Silber recalls from his first all-hands, highlighting demos of future model potential that underscore the pace.
Designers thrive by embedding with researchers, probing model strengths and failures. Silber emphasizes curiosity over technical depth: play with models, tweak behaviors via prompts, and productize capabilities. Rather than pixel-perfect mocks, teams explore token-level interventions. For onboarding, traditional tours yield to model-driven context injection. "We're really like stripping back a lot of maybe what you might traditionally do and trying to say, well actually what let's think about like how we should give this context to the model," Silber says. Prototyping involves system prompts; tweaks yield outputs tested for friendliness and clarity, bypassing Figma for direct model interaction.
Host Rid presses on balancing chat simplicity with advanced features. Silber admits no formal principles yet—intuition guides. Chat evolves beyond text: writing tasks now render editable containers for direct manipulation. Users select text, delete, or prompt changes locally, blending model responses with UI. Data revealed tedious loops in editing; the fix targets specifics without full rewrites. "We wanted to kind of lean into more direct manipulation," Silber notes, combining model logic (when to show containers) with ergonomic controls.
Dynamic Interface Library Builds Reusable Primitives
OpenAI invests in a "dynamic interface library" of composable blocks—beyond static components. Silber envisions models reasoning over these for task-specific UIs. Writing blocks exemplify: model detects use cases, outputs manipulable elements. Future expansions include math interactives, where designers prototyped step-by-step solvers after spotting archaic LaTeX outputs.
Systems thinkers excel by zooming out from isolated features. ChatGPT's fluid sessions—trip packing to email drafting—demand primitives like "skills" that encapsulate tasks. "The best systems thinkers are thinking not just about their feature, but how does this feature like extend the system," Silber argues. Build once, reuse everywhere: primitives enhance model composability, human readability, and scalability.
Silber references past tools like Origami (by Mike Matas and Brandon Walkin) for inspiration, but AI accelerates. Cursor and Codex enable live prototypes; a designer observing poor math rendering built interactive versions via prompts, rallying the team to ship.
Bottoms-Up Prototyping Powers Rapid Shipping
Ideas ship via prototypes, not specs. Designers, PMs, engineers, or researchers spark with code—Codex generates model-integrated demos. "It's become much easier to kind of build a working version of something," Silber says. Bottoms-up thrives: anyone prototypes, shares, iterates. Gaming startup scope creep taught discipline; OpenAI's generality invites experiments, but prototypes cut through.
From Friday game mechanics to Monday OpenAI launches, Silber's team adapted fast. AI tools evolved from Copilot autocomplete ("stone age" two years ago) to full workflows. Direct manipulation and math features stemmed from solo designer prototypes hardened collectively.
Evolving Design Practice with AI Tools
AI reshapes design: less pixels, more prompts. Silber's frontend stint pre-Codex involved manual coding; now, tools like Cursor output production-ready code. Rituals include model play, cross-team curiosity. Culture favors generalists thinking model-as-product.
Hiring seeks systems thinkers: curious explorers bridging research and users. No hardcore tech required, but comfort with flux. "You don't have to be like technical to work here, but I think you have to be really curious," Silber advises.
OpenAI tracks "capability gaps"—model limits dictating interfaces. Writing containers bridge gaps in precision; primitives systematize. "Things are changing underneath your feet all day long. And it's very exciting," Silber enthuses.
Key Takeaways
- Embed with models: Probe strengths, failures, and behaviors via prompts before UI.
- Prototype in code: Use Codex/Cursor for live model demos, not Figma mocks.
- Favor tokens over pixels: Solve via system prompts/context where possible.
- Build primitives: Create reusable blocks (e.g., editable writing containers) for model composition.
- Think systems: Extend features across fluid user sessions with skills-like abstractions.
- Ship bottoms-up: Anyone prototypes; rally teams around clear value.
- Balance chat purity: Direct manipulation for ergonomics, model for intelligence.
- Hire curious systems thinkers: Prioritize model intuition over pixel skills.
Notable quotes:
- Ian Silber on pixel-less design: "What can we do this without pixels? Can we do this with tokens?"
- Ian Silber on OpenAI's pace: "We're running very closely with where all of these advancements are going... Things are changing underneath your feet all day long."
- Ian Silber on systems thinking: "If you think about how people use ChatGPT, it's very fluid... The best systems thinkers are thinking not just about their feature, but how does this feature extend the system."
- Ian Silber on prototyping: "A designer will have this idea and now with Codex... you can build real versions of this that aren't just clickable prototypes."
- Ian Silber on model as product: "So much of our work is figuring out what the models are good at and then trying to wrap that in a product that people can understand."