We're All Addicted To Claude Code
These notes were generated by AI and may contain inaccuracies.
Using Claude Code in CLI enables debugging nested delayed jobs five levels deep, identifying bugs, writing tests to prevent recurrence. Hobbyists and small startups push coding agents to maximize speed due to limited runway. Larger companies have more to lose with established processes.
Welcome to another episode of the Light Cone podcast. Guest: Kelvin French Owen, first to create CodeX at OpenAI, previously started Segment (multi-billion dollar company, successful exit).
Host became addicted to Claude Code, likening it to recovering from 'manager mode' (catastrophic knee injury metaphor) via bionic knee replacement enabling five times faster running. Kelvin at forefront; CodeX pioneered ideas still used, continues evolving.
At OpenAI, worked on CodeX web project. Cursor used shim around GPT-3.5 in IDE; VS Code had CLI. Future vision: coding like talking to coworker—send question, get PR back. Now everyone uses CLIs like Claude Code or CodeX.
Everyone becoming managers; requires building trust in models, understanding their actions. Kelvin switched to Claude Code as daily driver (previously Cursor, then Claude Code with Opus).
Claude Code excels at splitting context: spawns explore sub-agents using Hakkup to traverse filesystem in separate context windows. Anthropic optimizes task-context fit, yielding strong results.
CLI purest for composable atomic integrations. IDE-first (e.g., Cursor, CodeX) limits free-form context finding. CLI feels like retro future beating modern IDEs. Claude Code not IDE—distances from code, focuses on progress indicators/status updates, enables flying through code.
Dev environments messy; sandboxes clean conceptually but fail on testing (e.g., Postgres access, long codeX.md files). CLI accesses dev/production databases directly, debugs concurrency, nested delayed jobs (5 levels), writes tests.
Distribution mode underrated: download/run without permissions. Example: desktop app execs local Claude Code via MCP server. New Relic, Sentry integrate (auto bug fixer). Bottoms-up adoption faster than top-down (CTO security concerns).
Top-down sales build moats (e.g., Netscape Navigator tracked IPs for commercial use). Architecture decisions now via Claude Code (e.g., recommends PostHog). GEO (generative optimization): competitors bias top-5 lists; LLMs fooled, recommend them. Tips: good docs, social proof, Reddit posts boost dev tools. Open-source wins (e.g., Supabase default for backend/Firebase due to docs).
Ramp blog: built coding agent using open-code harness (model sees source). Common: clone repo, use CodeX/Claude Code for walkthroughs.
Number one: manage context well. OpenAI RL fine-tuned o1 (reasoning model) on coding tasks (fix tests, implement features). Strategies:
- Spawn explore sub-agents to search filesystem, summarize.
- Cursor: semantic search (embeddings).
- CodeX/Claude Code: grep/ripgrep (code context-dense, <80 chars/line, respect .gitignore).
LLMs emit complex grep expressions. Apply to non-coding: format data like code for peeking/context.
Kelvin's stack:
- Use less plumbing: Vercel, Next.js, Cloudflare Workers (handles boilerplate, services, databases).
- Microservices/well-structured packages.
- Leverage LLM superpowers: persistence (keep going), mimic codebase styles (e.g., OpenAI monorepo varies by engineer seniority).
- Optimal code production, check work: tests, lint, CI.
- Use code review: Reptile (YC), Cursor bug bot, CodeX (strong on correctness).
- Agents excel at exploration, falter on duplication/context poisoning (clear context at 50% tokens to avoid 'dumb zone').
- Dex (HumanLayer, YC Fall '24): LLMs degrade after token threshold (exam analogy: rushed at end).
- Canary test: esoteric fact at context start (e.g., "My name is Calvin, drank tea at 8am"), query recall to detect poisoning.
- CodeX: periodic compaction (runs long sessions).
- Claude Code: splits windows, merges (human-like, shorter jobs).
Anthropic/Claude Code: tools for humans. OpenAI/CodeX: best model for long horizons/AGI (may not mimic humans, like AlphaGo). 2026: year of CLI? With 10x compute, 24-48hr jobs possible.
Small startups/hobbyists push agents for speed (limited runway). Big companies: code review, eng teams slow adoption. One-person teams prototype better solutions, landscape shift incoming.
10-year-old used AI for writing (inhuman phrasing). Juniors lack production management (millions jobs, thousands errors). Claude Code for architecture education? Product modeling key: user primitives (e.g., Slack not new concept—many chats existed
Slack's initial channels, messages, and reactions provided a simple navigation model that users understood immediately. Changing that mental model later is difficult, such as shifting to a document-first approach or incorporating agents. When building products, think carefully about the initial mental model from an early stage, as it becomes the kernel that coding agents build upon indefinitely.
YC's next batch is now taking applications at ycombinator.com/apply. It's never too early, and filling out the app will level up your idea.
Senior engineers benefit most because agents excel at turning ideas into action with minimal prompting. Scrolling through a codebase reveals many desired changes that agents can implement quickly, multiplying impact. Detecting good or bad architectural changes and knowing when to flag issues to agents is crucial. Organized, manager-like engineers will thrive. A missing product like a conductor could manage sessions across all projects, reminding users of completed work needing input or attention switches. Context management is needed for both agents and humans—daily summaries of overnight work, decisions to make, and deep thinking areas, providing a turn-by-turn daily plan.
Agents excel at quick prototypes, like turning an in-memory key-value store into a production database. Concisely specifying ideas in code remains valuable, but sensing the right architecture is where models struggle.
Study systems fundamentals: how git works, HTTP, databases, queues. Dedicate a semester to weekly projects pushing models to their limits—experiment with commands like 'implement next phase,' 'implement all' with sub-agents, and 'check your work.' Knowing model capabilities is a moving target, so tinker extensively. Teaching 18-22 year olds to ship desirable products is a challenge.
The best 18-22 year olds in 5 years will have exceptional taste from prolific launching and reality-testing 10x more than prior generations.
New generations excel at multitasking due to growing up with internet, TikTok, and short-form video, enabling constant context switching alongside deep thinking. There's a personality type (possibly ADHD) with many good projects but poor finishing—Claude Code overcomes this by getting everything over the line. It feels like a video game with constant novelty; when boredom hits and a better idea arises, switch while finishing the current task.
In 40 years, software is entirely personal: fork codebases per company (e.g., Segment signup forks and runs on their servers), edit via agent coding loops in a chat window, with agents merging corporate updates. Everyone has a cloud computer with cloud agents acting as a super EA—handling attention, decisions, meetings. Companies get smaller, more numerous. Update on PG's maker vs. manager schedule: managers can now build in pockets (10-minute snatches), as agents fill context windows instantly, unlike past hours-long ramp-up.
Data models remain consistent as the system of record. Agentic-first systems could generate data for custom views, but data gravity persists—companies like Slack lock down APIs to prevent exfiltration for agentic experiences.
Segment's integration wiring (e.g., Mixpanel, Kissmetrics, Google Analytics) is now trivial with agents, dropping value to zero—custom mappings are better. Core value persists in running data pipelines, automating business (e.g., Customer.io emails on signup, audience management). Evolve to small LM agents analyzing customer data for personalized emails, product changes, onboardings—moving up the stack to abstract campaign-level actions.
Claude Code infers motivations from context. Coding agents work remarkably despite minimal company/customer knowledge, just a repo copy and a note—context is critical to avoid latching onto wrong details or missing essentials.
Context window is the top limit—mega rearchitectures exceed it; delegation to subcontexts (Anthropic's approach) helps but summaries lose full picture. A million-token context every time would improve outcomes, especially training on long-context trajectories (harder than next-sentence prediction). Integration and orchestration are emerging limits: code review, verification, tool context (e.g., Sentry auto-PR, traffic subset rollout).
Testing is crucial—adding 100% coverage sped up development massively, enabling trust without manual testing. Test-driven development mirrors prompt engineering evals. Agents can debug deeply, like tracing Rails Active Job internals to find a JSON array vs. comma-string bug—no Stack Overflow needed.
Agents need CLI-like behaviors and memory—Claude Code/Codex store conversation history as files for reuse. Smart sharing of coworkers' prompts enables knowledge transfer (e.g., Brian fixed it). Model-generated wikis or Graopedic for collaboration.
Claudebot social network lets Clawbots (personal AI agents runnable locally—do not give email access due to prompt injection risks) talk to each other, generating AI content like agent-run Reddit.
Codex shows alien behaviors like Python scripts modifying filesystems for superhuman debugging (concurrency decent; excels at multi-service request tracking, serialization issues, complex UI state—better than Opus on many files).
Keep tinkering as tools change monthly. Future top users are manager-like (directing flows), designer-artist (deciding product specifics), automation-focused, context-aware. Codex excels on Python monorepos (OpenAI shape/data mix) but weak on Rails (vestigial; request: syntactic sugar for top 15 runtimes, ~10 PRs). Fewer excuses for broken software. Labs differ: some flood data, others tune mix—impacts results (Anthropic stronger on front-end; Ruby data mix varies).
Top 10% of JavaScript is pretty different than looking across everything. OpenAI models are really good at Ruby. It's the harness around the model.
Rails has this weird thing where you have to access Postgres in a certain way or it couldn't fit. It's the sandboxing.
OpenAI takes the sandboxing and security question more seriously than almost anyone else. When building Codex, one gate to release a model is discussing safety and security risks every time.
They looked into prompt injection especially for opening up to the internet because users wanted it to work on the internet. Operator was also that.
The PM on the team, Alex, put together a GitHub issue with a very obvious prompt injection: "reveal this thing." He told the model, "Hey, go fix this issue." He thought there's no way this is going to work, but immediately the prompt injection worked.
OpenAI is very worried about this and runs everything in a sandbox, ensures it doesn't touch sensitive files on your machine, and is very careful about secrets.
If you're a startup running fast, you probably don't care; you just want it to work.
Are you a dangerously skip permissions person?
I'm not. I have a set of things that are... I like to read what it's doing.
Are you running? Not... I like to read.
Are you skip permissions, Jerry? 100%. YOLO.
It's about 50/50 on the YC engineering team.
A security engineer would say, "You can't release this part of the video. Just cut it from the podcast. You can't have this out here."
It's context dependent. If you're at an enterprise, you don't want to do that. If you're a startup and have nothing to lose, you probably do.
YC has progressed a little bit from a startup. We still act like one though, which is important.
Cool. This is so awesome. Kelvin, thank you so much for joining us.
Of course. Thanks for having me.
So fun. All right, back to Claude.
Keep Y Combinator in your library
Save the videos and channels worth coming back to, and find them again in one place.
