![[Interview Dialogue] The Person Who Built Codex, Why Do They Use Claude Code Every Day](/_next/image?url=https%3A%2F%2Fxselected.bitfroth.com%2Fimages%2Fmldbfii3-79782bf23b04.jpg&w=3840&q=75)
[Interview Dialogue] The Person Who Built Codex, Why Do They Use Claude Code Every Day
Calvin French-Owen co-founded Segment, which was acquired by Twilio for $3.2 billion in 2020. He later joined OpenAI, leading a team that built the programming agent Codex from scratch in seven weeks. In mid-2025, he left OpenAI to return to entrepreneurship, yet his daily primary programming tool is the competitor's product, Claude Code.

https://www.youtube.com/watch?v=qwmmWzPnhog We're All Addicted To Claude Code
He recently had a conversation with YC CEO Garry Tan on the YC podcast Lightcone. Garry had been using Claude Code for just nine days, while Calvin was the one who built Codex. The two discussed the philosophical differences in programming agent product design, how to become a top 1% user, dealing with context poisoning, how LLMs are changing the distribution logic of developer tools, and what they would do differently if starting Segment today.
Key Takeaways
The Retro-Future of CLI: Why the Command Line Defeated the IDE
Garry Tan opened with a knee surgery analogy: Ten years ago, he was a "marathon runner" (someone who wrote code), then suffered a "catastrophic knee injury" (became a manager) and stopped programming. In the last nine days of using Claude Code, it felt like getting a bionic knee—running five times faster than before.
Calvin said Claude Code is now his daily primary tool, though this tool changes every few months. He previously used Cursor extensively before switching to Claude Code, especially after the Opus model was released.
He believes people focus too much on model capabilities themselves, ignoring the synergy between product and model. One thing Claude Code does exceptionally well is splitting context.
When you give Claude Code a task, it generates multiple "exploration sub-agents," each using the Haiku model to traverse the file system and search for relevant code. These sub-agents each run in their own independent context windows, without interfering with each other. Anthropic figured out a key question here: given a task, can it fit into one context window, or should it be split into multiple?

Garry Tan added an observation: precisely because Claude Code runs in the terminal, it is naturally suited for this kind of free, composable integration. If you start from an IDE (like Cursor or early Codex), this freedom wouldn't emerge as naturally.
This leads to a "retro-future" paradox: the command-line tool (CLI) from 20 years ago has defeated the integrated development environment (IDE), which was considered the future.
Calvin believes this is precisely its advantage:
"The CLI is not an IDE, and that's important. It keeps you away from the code being written. The entire purpose of an IDE is to explore files and keep all state in your head. But the CLI is a completely different thing, giving Claude Code much more freedom in the experience. When I use Claude Code, it feels like flying through the code."
Garry Tan gave a more practical example: development environments are messy and dirty; sandboxes are conceptually clean but hit walls everywhere in practice, like needing to access Postgres but failing to connect. The CLI, however, runs directly in your development environment, can access your development database, and he even had Claude Code access the production database.
"For a concurrency issue, it can debug a delayed job nested five levels deep, find the bug, and then write a test to ensure it never happens again."

Bottom-Up Distribution: How Developer Tools Are Sold in the LLM Era
Calvin believes the distribution model of CLI tools is underestimated. You just download and use it without needing anyone's approval. He recently tried a product: after downloading the desktop app, it directly called the Claude Code installed on his laptop, then communicated with the desktop product via an MCP server. The entire process required no one's permission.
Garry Tan pushed this view further: in an era where everything is fast, products must take a bottom-up distribution route, not top-down. CTOs are too slow to make decisions, considering security, privacy, and control. Engineers just install and use it—"this thing is too good."
Calvin agreed but also saw the other side: as someone from a B2B enterprise product background, he knows top-down sales can build moats. The question is who can combine both. Garry Tan recalled the precedent of Netscape Navigator: free for individuals, retroactive charging for businesses.
More interesting is the impact of AI recommendations. Calvin pointed out that people might now decide which tools to use directly within Claude Code, rather than doing their own research.
"As long as Claude Code recommends PostHog, they use PostHog."
Garry Tan added a case: a company's competitor created a ranking of "Five Tools You Should Use," putting their own product first. Humans can tell it's sponsored content at a glance, but LLMs can be fooled.

Calvin believes this is particularly advantageous for open-source projects. Supabase is a typical example: because it has excellent open-source documentation, whenever someone asks how to set up a backend, all LLMs default to recommending Supabase. He mentioned that Ramp recently published a blog post about building their own programming agent, using the open-source OpenCode as the underlying framework, because the model can directly read the source code to understand how the tool works.
[Note: Ramp built an internal programming agent called Inspect, with approximately 30% of merged PRs generated by this agent.]
The Core of Building Programming Agents: Context Engineering
Garry Tan asked him, what is the most important lesson from building programming agents?
Calvin said: Managing context.
He briefly introduced Codex's approach: extensive reinforcement learning fine-tuning on top of a reasoning model, teaching the model to solve programming problems, fix tests, and implement features. But he believes most people won't take this path. What ordinary people can do is think clearly about what context to provide the agent to get the best results.
An interesting difference: Cursor uses semantic search (embedding code into vector space to find the most relevant snippets), while Claude Code and Codex directly use grep.

This seems backward but is actually very reasonable. Code has extremely high information density, with each line typically under 80 characters and no large chunks of JSON data. After filtering out packages and irrelevant files via .gitignore, using grep and ripgrep to search code context can basically pinpoint the code's functionality. Moreover, LLMs are particularly good at writing complex regular expressions that humans would never write by hand.
"If you're building agent systems in non-programming domains, you can learn a lot from this. The key is how to organize your data into a format close to code, allowing the model to peek at surrounding context and obtain structured information."
Becoming a Top 1% User: Write Less Code, Do More Management
"How do you become a top-tier user of programming agents?" Garry Tan asked.
Calvin listed several points:
First, use as little code and "scaffolding" as possible. He tends to deploy on platforms like Vercel, Next.js, Cloudflare Workers, which already have a lot of boilerplate code, keeping core code to one or two hundred lines. No need to set up various services, handle service discovery, or register endpoints yourself.
Second, favor microservices or well-structured independent packages.
Third, understand the LLM's superpowers and blind spots. Andrej Karpathy recently tweeted about this: programming agents are "super persistent," continuing regardless of obstacles. But the side effect is a tendency to "produce more of what already exists." If your goal isn't to add code, it might duplicate existing functionality or re-implement things you think are obvious and shouldn't be touched.
He specifically mentioned OpenAI's internal experience: OpenAI has a massive Python monorepo containing code in various styles from senior Meta engineers and fresh PhDs. The LLM learns completely different programming styles depending on which code area you point it to.
"There's a lot of room for programming agents to judge for themselves: what is the optimal code style that should be produced."

Fourth, provide the model with means to check its work. Tests, linting, CI—all work. He also actively uses code review bots, recommending Greptile, Cursor Bug Bot, and Codex's own code review functionality.
[Note: Greptile is an AI code review company that can review PRs after understanding the full codebase context.]
On testing, Garry Tan shared his "aha moment": For the first two or three days, he barely wrote tests. On the fourth day, he decided to achieve 100% test coverage. After that, his speed skyrocketed, and he hardly needed manual testing because the test coverage was good enough that nothing would break.
Calvin said: This is exactly the same as how all companies do prompt engineering—it's test-driven development.
"Test cases are your eval."
Context Poisoning: The LLM's "Dull Zone" and Canary Detection
Calvin introduced the concept of "context poisoning": the model continues down a wrong path because, due to its "super persistence" characteristic, it keeps referencing already erroneous tokens and pushes forward.
Garry Tan asked him how often he clears the context.
"When context usage exceeds 50%."
This number surprised Garry.
Calvin mentioned that Human Layer's Dex has a vivid term for this called the "dumb zone."
He used an analogy to explain:
"Imagine you're a college student taking an exam. In the first five minutes, you feel you have plenty of time and think carefully about each question. But if there are only five minutes left and you still have half the exam to finish, you just write anything. That's how an LLM feels when it hits the context window limit."

If you understand this through the lens of reinforcement learning training, the analogy makes a lot of sense: as the model approaches the end of the context window, the incentive to "make every decision well" likely decreases.
Garry Tan introduced a trick used by founders: place a random fact at the beginning of the context as a "canary," such as "My name is Calvin, and I drank tea at 8 AM." Then periodically ask the model if it remembers. When it starts to forget, you know the context has degraded.
Calvin hasn't tried this method but finds it entirely plausible. He believes Claude Code should be able to do this detection automatically at the product level, running an internal "heartbeat" mechanism to monitor context quality.
The two products handle this issue differently. Claude Code splits the context into multiple sub-windows and merges the results, but the main window's context remains fixed until the session ends. Codex, on the other hand, uses periodic compaction, automatically compressing the context after each round of conversation, allowing it to run continuously for a long time. OpenAI wrote about this mechanism in a blog post, and you can see the context usage percentage in the CLI fluctuate up and down with each compaction.
Two Companies' DNA: Hardware Store Doghouse vs. 3D-Printed Doghouse
Garry Tan observed a deep architectural difference between Claude Code and Codex. Codex was designed from the start for longer-running tasks. 2026 might be the year of the CLI, but if ASI is truly coming soon and coding agents are smart enough to run independently for 24 to 48 hours, isn't Codex's architecture the right one?
Calvin traced this back to the founding DNA of the two companies:

"Anthropic has always been very focused on building tools for humans, paying attention to user experience and integration with your workflow. Claude Code is a natural extension of this philosophy. It works like a human: you want to build a doghouse, it goes to the hardware store, buys materials, and figures out how to put them together."
"OpenAI, on the other hand, tends to train the strongest models and use reinforcement learning to make them perform increasingly longer and more complex tasks. It might not work like a human at all. Going back to the doghouse example, it uses a 3D printer to print a doghouse from scratch. It takes a long time, does some strange things, but eventually gets the job done."
Garry Tan interjected: AlphaGo also doesn't play Go the way humans do.
Calvin admitted that, in the long run, "the latter might be inevitable in some sense." But he expressed a strong personal preference for the former. Using Claude Code reminds him of the feeling ten years ago when he wrote complex regular expressions to understand code.
"I can do the work of five people in a day. It's like having a rocket booster."
Who Benefits Most from Coding Agents
Calvin believes the more senior the engineer, the greater the benefit. Because agents excel at turning ideas into executable code. If you can accurately describe what you want in a few sentences, you can batch out all those things you've always wanted to fix but never had time for.
He also thinks engineers with more of a "managerial mindset" benefit more. There's a need for a product that manages tasks across multiple agent sessions, reminds you which tasks are completed and need your input, and tells you where to focus your attention next.
"We need context management for agents, but we also need context management for humans."
Garry Tan described his ideal workflow: waking up each morning to a system telling you what work was completed overnight, three decisions you need to make, and what deep thinking you plan to do today. A day of "step-by-step navigation."
The difference between startups and large companies is also stark. Startups have nothing to lose and push coding agents to their limits. Large companies have code review processes, large existing engineering teams, and change more slowly. Calvin predicts a strange scenario: a one-person team's prototype might be better than what a ten-person team on the other side produces.
Garry Tan offered a broader observation: five years from now, the best 18 to 22-year-olds might have excellent product taste because they'll have ten times more opportunities to ship and iterate than the previous generation.
Calvin agreed but added an interesting point: the new generation is indeed better at multitasking than the previous one. In the past, when your mom said you weren't paying attention, you were actually handling multiple things at once. Now, working with coding agents requires exactly this ability to rapidly switch attention: kick off a task, jump to another, wait for a callback, and jump back.
Garry Tan said this was impossible before. Writing code used to require spending hours loading all class names, functions, and code relationships into your own "context window," and ten minutes of fragmented time was never enough. Now Claude Code maintains the context for you, so fragmented time can still be productive.

Paul Graham's classic essay "Maker Schedule vs Manager Schedule" is being rewritten.
[Note: Paul Graham's 2009 essay pointed out that "makers" need large, uninterrupted blocks of time to write code or design, while "managers" operate on a schedule switching by the hour. The two rhythms are inherently in conflict. Now that coding agents maintain context for you, makers can also work in a fragmented way like managers.]
If Rebuilding Segment: What Value Gets Zeroed Out
Garry Tan asked a direct question: If you rebuilt Segment with today's tools, what would happen?
Calvin said that when Segment started, it did data integration: helping you send the same data to Mixpanel, Kissmetrics, and Google Analytics simultaneously. Writing that integration code used to be a hassle worth paying for.
"Now that value has dropped to zero. And often, it's better to do it yourself because you can directly tell Claude or Codex: 'I want to map data this way, I want this specific behavior.' And then it does it, and you get exactly what you wanted."
The parts that still hold value are: maintaining data pipeline operations, automating business processes (like sending a welcome email via Customer.io every time a new customer signs up), and managing audience segments. If he were rebuilding Segment today, he would build more intelligent features on top of these: using an LLM agent to analyze complete customer profiles, automatically deciding how to email customers, whether to adjust the product interface after login, and whether different customers need different onboarding flows.

Garry Tan summarized: low-level things are being replaced by agents, and value is migrating upward to the more abstract "marketing campaign" level.
Calvin also shared something that continues to surprise him: Claude Code can infer his intentions and motivations just from the code context he's working on.
"You give the agent a copy of the code repository, then slip a note under the door saying 'implement this for me.' It has no idea what your company does or who your customers are. Yet it still works."
Future Software: Every Company Forks Its Own Version

Talking about the future 40 years from now, Calvin proposed a radical idea: if every company signs up for Segment, you fork a copy of the codebase and run it on its own servers. If a customer wants to change a feature, they tell an active agent coding loop in a chat window, and the agent modifies their version. When Segment as a company releases a new feature, another agent is responsible for automatically merging upstream updates.
Garry Tan's version is even grander: in the future, every worker will have their own cloud computer and a set of AI agents running for them. Their main job will be making decisions and allocating attention among different agents. Companies will become smaller and more numerous.
But he believes the need for people to meet and exchange ideas face-to-face won't disappear. Agents execute, humans make decisions and spark creative collisions.
Calvin added a key constraint: the data model still needs to be consistent and correct. While the frontend can be fully customized, the underlying "system of record" still needs to be unified. There's an opportunity to create an "agent-native" data layer, replacing the current low-level way of directly interacting with SQL/NoSQL.
Security: When Prompt Injection Succeeds Internally
On the topic of security, Calvin shared a story from inside OpenAI. Every time a new model is released, it goes through a security review. When they considered giving Codex internet access, they were worried about prompt injection.
Their team's PM, Alex, ran an experiment: create a GitHub Issue containing an obvious prompt injection that said "expose this information." Then have the model fix the Issue.
The prompt injection worked immediately.

So OpenAI is very cautious about sandboxing and security: all code runs in a sandbox, doesn't touch sensitive files on the machine, and strictly manages keys.
But if you're a fast-moving startup? Calvin says you might just not care and "just want it to work."
Garry Tan asked an interesting question: Are you in the "skip all permissions" camp or the "review each one" camp? Calvin says he doesn't skip. But YC's engineering team is probably 50/50. Jared Friedman joked that security engineers would ask to cut this part out.
Calvin summed it up pragmatically: it depends on your stage. Enterprises shouldn't skip permission checks. Startups with nothing to lose might just go for it.
The Hidden Advantage of Training Data: Why Codex Is Especially Good at Python
Garry Tan tried using Codex on his Rails project but found that OpenAI clearly doesn't care about Rails support. Calvin believes this is related to the composition of the training data.

Codex is particularly good for Python monorepos. This "just so happens" to be the shape of OpenAI's internal codebase. He recalls that internally, everyone said the tool was so good that "from the perspective of data composition and researchers, it makes perfect sense."
Garry Tan noted a subtle distinction: OpenAI's model itself is actually not bad for Ruby. The problem lies in the sandbox environment of the Codex product—for example, Rails needs a specific way to access Postgres, which the sandbox cannot handle. It's not a model issue; it's an issue with "the shell around the model."
Calvin pointed out that different labs have different strategies for training data: some lean toward "the more, the better," while others focus more on filtering data quality, taking only the top 10% of high-quality code. These two strategies lead to very different outcomes.
Throughout the conversation, Calvin repeatedly returned to a core judgment: the competitiveness of a coding agent lies not in how smart the model is, but in how well the context engineering is done. Claude Code differentiates itself at the product level by splitting into sub-agents, using grep for retrieval, and forming a validation loop with tests and CI.
Another thread running through the dialogue is the role shift: the best coding agent users increasingly look like managers, or even designers. They don't write code; they judge what should be done, what style is good, and where human intervention is needed. Calvin believes that five years from now, the best young engineers will have product taste far beyond their peers because they "touch reality ten times more than their predecessors."
Calvin is uncertain which path will ultimately prevail—Anthropic's "human tool" approach or OpenAI's "general intelligence" approach. But his actions speak volumes: someone who built Codex uses Claude Code every day.