We're All Addicted to Claude Code

The CLI won. Not the IDE, not the web app, not the sandbox. The command-line interface, a technology from 20 years ago, has become the dominant surface for AI-assisted coding. And Garry Tan, the CEO of Y Combinator, describes his experience with Claude Code like getting a bionic knee after a catastrophic injury called “manager mode.”

A Retro Future Nobody Predicted

YC’s Lightcone brings on Calvin French-Owen, who co-founded Segment (multi-billion dollar exit) and then helped build Codex at OpenAI. The conversation is less a product review and more a real-time autopsy of how coding agents actually work under the hood, why the CLI form factor matters architecturally, and what happens when every engineer becomes a manager of AI workers.

Garry opens by confessing he spent nine days straight coding with Claude Code after years of being stuck in manager mode. Calvin, who has switched between Cursor, Claude Code, and Codex over recent months, brings the rare perspective of someone who has both built and heavily used these tools.

Why the CLI Beat the IDE

Calvin makes a counterintuitive point: Claude Code benefits from not being an IDE. IDEs are built around exploring files and keeping state in your head. The CLI distances you from the code being written, which paradoxically gives the tool more freedom.

“I feel like when I’m using Claude Code, it’s like, oh, I feel like I’m flying through the code. The code that’s being written is not the front and center thing.”

The more practical advantage: a CLI agent has direct access to your entire development environment. It can hit your local Postgres, run your test suite, access your job queues. Garry describes watching Claude Code debug nested delayed jobs five levels deep, find the bug, and write a test for it. Codex’s sandbox approach, by contrast, struggles with anything that needs to touch real infrastructure.

Context Engineering Is the Real Superpower

Calvin identifies context management as the single most important factor in coding agent performance. The key architectural insight: Claude Code spawns multiple “explore sub-agents” running Haiku to traverse the file system, each in their own context window. Anthropic figured out how to determine whether a task fits in one context window or should be split across many.

The approaches diverge by company. Cursor uses semantic search with embeddings. Claude Code and Codex use grep and ripgrep. Calvin argues the simpler approach works because code is incredibly context-dense: short lines, minimal data blobs, navigable folder structures. And LLMs are surprisingly good at emitting complex grep expressions that would “torture a human.”

For building your own agents for non-coding work, Calvin suggests the lesson is clear: get your data into a format as close to code as possible, where the model can peek at surrounding areas and get structured context.

Becoming a Top 1% Coding Agent User

Calvin’s practical tips for maximizing coding agent productivity:

Minimize boilerplate. Deploy on platforms like Vercel, Next.js, or Cloudflare Workers where infrastructure is already handled. Operate in microservices or well-structured packages of 100-200 lines.

Know the LLM’s tendencies. Agents are relentlessly persistent and will “make more of whatever’s there.” If your codebase has inconsistent patterns (like OpenAI’s giant monorepo with contributions from senior Meta engineers alongside new PhDs), the agent will pick up different styles depending on where you point it.

Give the model ways to check its work. Tests, linting, CI. Calvin uses multiple code review bots aggressively, including Reptile (a YC company), Cursor’s bug bot, and Codex for correctness review.

Clear context aggressively. Calvin clears context when it hits about 50% of the token window. He references Dex from Human Layer (YC Fall ‘24), who coined the concept of the “dumb zone,” where LLM quality degrades past a certain token threshold. The analogy: a college student with five minutes left on an exam stops thinking carefully and just rushes.

One creative trick: plant a “canary” at the beginning of your context, some random esoteric fact. Periodically ask the model if it remembers. When it starts forgetting, your context is poisoned.

Two Philosophies: Anthropic vs OpenAI

Calvin draws a revealing contrast between how the two companies approach coding agents, rooted in their founding DNA:

Anthropic builds tools for humans. Claude Code works like a human would: go to the hardware store, gather materials, figure out how they fit together. The emphasis is on tone, style, and fitting with the rest of your work.

OpenAI trains the best model and uses reinforcement learning for longer-horizon tasks. Codex runs compaction periodically after each turn, enabling much longer sessions. It may not work like a human at all, like AlphaGo playing moves no human would. Think of it as a 3D printer that can print a doghouse from scratch: weird, slow, custom, but it works.

“Net net it seems like the latter is somewhat inevitable, but I like the former so much.”

The architectural difference is real: Codex is designed for 24-48 hour autonomous jobs. Claude Code is designed for interactive human-agent collaboration. Calvin sees the long-running autonomous approach as “somewhat inevitable” but finds the human-collaborative approach more enjoyable right now.

The Manager-Maker Boundary Dissolves

Paul Graham’s classic “maker schedule vs manager schedule” essay assumed a hard boundary. Coding agents are dissolving it. Garry, stuck in manager mode for years, found he could code again in 10-minute pockets between meetings because the agent already holds the context.

“It used to be that in order to write any code, you had to fill your own context window with so much data about all the different class names and the functions. It would take hours to build up that context window.”

The observation has a deeper implication: if managers can now code, and coding is increasingly about directing and reviewing agent work, then the distinction between “maker” and “manager” may just be a spectrum of how many agents you’re running.

Calvin thinks the people who will get the most out of coding agents are “more manager-like” in their orientation: directing flows, maintaining taste for what specifically goes in the product, and thinking about automation. The role starts to look more like “designer-artist” than “engineer.”

Testing: The Unexpected Force Multiplier

Garry describes a revelation from his nine-day coding sprint. He operated without tests for the first 2-3 days, then devoted a day to reaching 100% test coverage. The speed improvement was dramatic.

This mirrors a broader pattern: test-driven development has become essential for AI-assisted coding, exactly as evals have become essential for prompt engineering. The test cases are your evals. Without them, the agent has no way to verify its own work.

Rebuilding Segment in the Agent Era

Calvin’s honest assessment of his own company: the integration layer that made Segment valuable (wiring up data to Mix Panel, Kissmetrics, Google Analytics) has had its value “drop to zero.” Writing those integrations is now trivial with coding agents.

What retains value: the data pipeline orchestration layer. Scheduling email deliveries through Customer.io, managing audiences, automated campaigns. And there’s a new opportunity: running small LLM agents over customer data to dynamically personalize onboarding, product features, and communications.

The Bottom-Up Distribution Revolution

The group observes that developer tool distribution has fundamentally shifted. Top-down enterprise sales are “just too slow” in a world changing this fast. Engineers install Claude Code or Codex and start using it without asking permission.

This creates a new dynamic: coding agents are now making architecture decisions. If Claude Code recommends PostHog for analytics, that’s what gets used. Calvin describes a company whose competitor gamed “generative engine optimization” by creating a biased “top 5 tools” list that LLMs now cite as authoritative. Open-source projects with good documentation (like Supabase) benefit disproportionately because they dominate LLM training data.

Agent Memory and Collaboration

Calvin identifies a missing piece: shared agent memory across teams. Both Claude Code and Codex store conversation history as files, enabling individual memory. But there’s no way for agents to share knowledge across team members. Imagine knowing that your coworker’s agent already solved the same bug you’re hitting.

The group also discusses Claudebot Social, a network where personal AI agents talk to each other, which Calvin sees as a glimpse of where agent collaboration could go.

Afterthoughts

• The “dumb zone” concept deserves more attention. Context degradation isn’t gradual; it hits a cliff. The canary trick is a practical workaround for a problem that should eventually be solved at the model level.
• Calvin’s framing of the Anthropic vs OpenAI approach as “hardware store” vs “3D printer” is the clearest articulation of why these products feel so different despite doing the same thing.
• The observation that Segment’s integration value dropped to zero is a leading indicator for an entire category of SaaS. Any product whose core value is “we do the boring wiring for you” is on borrowed time.
• Testing isn’t just good practice anymore; it’s the mechanism by which AI agents verify their own work. Skipping tests with coding agents is like removing the feedback loop from a control system.
• The most underexplored idea: agents making architecture and tooling decisions for engineers. The implications for developer tool marketing, open-source strategy, and LLM training data curation are enormous.