OpenAI Codex lead on the new shape of product work | Andrew Ambrosino
with Andrew Ambrosino
28 Jun 20265 min read1h 10m
TL;DR
Andrew Ambrosino argues that AI has inverted the product development process — implementation is now cheap and abundant, making taste, curation, and judgment the scarce and valuable resources. The old design process was built on the assumption that building was expensive, and that assumption is simply gone. The new challenge isn't building; it's knowing what to build and recognizing which of 90 parallel prototypes is actually good.
Key Moments
Andrew Ambrosino
“it's backwards, right? The implementation is actually not the expensive part anymore. It's dare I say taste. Um but it's the curation process. It's like of those 90 attempts like what's good about these? What should we fold into other aspects of this? Right? How should we frame this? Should it be part of this other feature? Right? How many segments should be in the toggle?”
Andrew summarizing how the product development process has fundamentally inverted at OpenAI
“it's very tempting to jump straight to a prototype, especially if you're not an engineer, right? Especially if you've never been able to write code or never been interested or never had the time. It's really tempting to say like PRDs are dead. Let me just show you what I mean.”
Andrew pushing back on the popular claim that PRDs are dead and prototypes should replace all written documentation
“I think design's a little bit harder to grade um than software and that you know creating a loop where you can train the model on like what's good design and what's bad design is just a little bit more tedious and ownorous than you know does the code compile does it you know do what it's supposed to right it because the human aspect of taste is like part of the feedback mechanism you need”
Andrew explaining why AI frontier models lag behind in design capability compared to coding
“there is a desire among all of us to try to do as much as possible in the app even when it's not the best tool so that it can become the best tool. And so a lot of design we all work on by using the app and say okay what's broken about this? This is a whole thing we do which is that we often don't improve our process so that we can make the product better to do it which is a deeply like uncomfortable place to be in”
Andrew describing the Codex team's dogfooding philosophy — deliberately using their own product even when it's painful, to drive improvement
“I've heard a lot of companies be like we're getting rid of the product role and everybody's just going to be a builder and then what happens is they don't like this whole discipline of product that's been built up and has like real best practices, real things that have been tried and failed and like real processes like that just gets abandoned because people are like, "Oh, I wrote some code, right?"”
Andrew warning against the trend of eliminating the product manager role in favor of everyone being a 'builder'
Andrew Ambrosino is the product and engineering lead for the Codex app at OpenAI. He is a designer-turned-engineer-turned-product-manager who has also founded companies. Under his leadership, Codex has grown 6x in usage since January and now has over 5 million weekly active users.
Takeaways
1
Implementation is cheap; taste is now scarce Because anyone can spin up a working prototype with AI, the bottleneck in product work has shifted from execution to judgment — knowing which of 90 parallel builds is actually good, how to frame it, and what to do next. This inverts decades of product process assumptions built around expensive implementation.
2
PRDs aren't dead — pick the right medium Andrew argues that the 'PRDs are dead, just prototype' mantra is a mistake. The right artifact depends on what you're trying to learn: a document for product clarity in a vague area, a prototype for stress-testing an interaction. The danger is anchoring too early on a polished-looking prototype that isn't actually the right direction.
3
Product managers should play 'zone defense' With everyone generating ideas and prototypes simultaneously, PMs should spread out for full coverage rather than cluster together. The job is less about owning a roadmap and more about steering the chaos — finding gaps, aligning explorations, and guiding things from inception to a coherent product direction.
4
Dogfooding deliberately, even when it hurts The Codex team intentionally uses Codex for their own design and product work even when it's not yet the best tool for the job. They accept the friction rather than switching to better tools, because using it under real conditions is what surfaces what needs to be fixed.
5
Roles aren't vanishing — their boundaries are blurring The Codex team has seen role collapse, but Andrew warns against eliminating roles entirely. Disciplines like product management have accumulated real best practices that get lost when everyone just becomes a 'builder.' The healthy shift is overlapping roles defined by the average of what someone works on, not rigid fences.
6
AI lags at design because taste is hard to grade Unlike code — which can be evaluated by whether it compiles or passes tests — design quality requires human taste as part of the feedback loop, making training loops harder to construct. Labs have also historically prioritized model capabilities that accelerate AI research, and design doesn't fit that flywheel.