Why CTOs should stop asking whether they trust AI agents and start asking when that trust becomes automatic, and where human judgment still has to hold the line.

Sponsored by Blocks: Save at least 20% on your AWS costs with AI-powered optimization and enterprise discounts. Get your free Cloud Check at https://blocks.cloud/alphalist?utm_source=alphalist&utm_medium=podcast&utm_campaign=blocks-podcast-2026

Dana Lawson, CTO at Netlify, joins Tobi for a candid conversation about the changing role of software engineers in the age of AI agents.

Dana's path into technology began in the US Army in the late 1990s. She started by managing backup tapes and automating manual workflows before moving on to engineering leadership roles at GitHub and Netlify. The conversation explores why Dana believes "writing code is no longer the job," how AI agents are changing software development, and why trust in agents may eventually become as automatic as trusting a car we cannot repair ourselves.

Topics covered

Dana's path from the US Army to GitHub and Netlify How automating password resets sparked her interest in software Why Dana argues that writing code is becoming a commodity The Hacker News reaction to her article, "Writing Code Is No Longer the Job" The self-driving car analogy for trusting AI agents Why "agent experience is human experience" How Netlify is adapting its platform for an agentic future The shift from writing code to defining architecture and guardrails The tension between speed, control, reliability, and safety Whether developers could become the bottleneck Why the key constraint may be moving from "can we build it?" to "does anyone actually want it?" The future of developer experience, CMS platforms, databases, and the web

Timestamps

[00:00:51] Introduction and Dana's background [00:01:44] Dana's path from art school to the US Army [00:03:51] Backup tapes, automation, and the origins of her DevOps mindset [00:06:03] Moving to GitHub and learning to operate at scale [00:08:33] How AI could change GitHub and the software development lifecycle [00:12:18] The self-driving car analogy for trusting AI [00:16:20] AI, productivity, and whether more software is always better [00:19:43] Dana's "30 apps in 30 days" challenge [00:20:00] "Writing Code Is No Longer the Job" and the Hacker News backlash [00:25:00] Craftsmanship, abstraction, and the changing role of developers [00:30:28] Control, governance, and building for the future [00:33:59] What the agentic shift means for Netlify [00:37:53] From developer experience to agent experience [00:39:02] The future role of DevOps, SRE, and release engineering [00:49:11] CMS platforms, databases, and the future of the web [00:53:19] Dana's side projects and what people actually want [00:55:38] The closing time-machine question

What you'll learn

• Why AI agents may change the entry point into software development
• Where human expertise remains essential
• How engineering teams can think about guardrails and safe deployment
• Why product judgment and demand may matter more than implementation speed
• How platform teams can create better experiences for both agents and humans

About Dana Lawson Dana Lawson is the CTO at Netlify. Before joining Netlify, she was VP of Product Engineering at GitHub. She began her technology career in the US Army, where she developed an early interest in automation and infrastructure.

Relevant links

• Netlify: https://www.netlify.com
• Dana Lawson's article, ["Writing Code Is No Longer the Job"]
• alphalist Slack community: https://alphalist.com/apply
• alphalist events and community: https://alphalist.com

Join alphalist Are you an experienced CTO or engineering leader? Join more than 600 CTOs sharing insights, challenges, and practical advice in the alphalist Slack community. Apply at https://alphalist.com/apply

Sponsored by Blocks: Save at least 20% on your AWS costs with AI-powered optimization and enterprise discounts. Get your free Cloud Check at https://blocks.cloud/alphalist?utm_source=alphalist&utm_medium=podcast&utm_campaign=blocks-podcast-2026

A GitHub repo, a Cursor cloud agent, and a public Slack channel replaced Notion AI at a $25M-funded HR integration startup, and became the whole company's shared brain.

BROUGHT TO YOU BY: Blocks

Save at least 20% on your AWS costs with AI-powered optimization and enterprise discounts. Get your free Cloud Check at https://blocks.cloud/alphalist?utm_source=alphalist&utm_medium=podcast&utm_campaign=blocks-podcast-2026

Two failed startups, a Y Combinator batch, and a $25M Series A later, Aike Hillbrands and his co-founders built Kombo into a $10M+ ARR HR integration platform, and then, almost by accident, built a company-wide AI brain out of a GitHub repo and a Cursor agent. Aike joins Tobi to explain why files and grep beat MCP tools for agent reliability, what the "lethal trifecta" of AI security actually means in practice, and why he doesn't think AI will commoditize his own business anytime soon.

chapters:

00:00:00 — Intro 00:01:00 — Meeting his co-founders at CODE University 00:03:00 — Founding Kombo — the YC S22 pivot 00:04:00 — Nerd origin story: graphic design, Delphi, and Windows Forms games 00:06:00 — Selling an early company, and the open-source interception tool 00:08:00 — The Workday pain point that became Kombo 00:10:00 — Grayish markets: intercepting API traffic, and when it's not worth it 00:12:00 — Team size, the $25M raise, and staying a bootstrapper at heart 00:14:00 — From Notion AI to a company-wide brain 00:16:00 — Why the MCP experiment failed — and files + grep won instead 00:18:00 — Eliminating the "ask an engineer" bottleneck 00:20:00 — Two hours to build the repo, five minutes for Slack 00:22:00 — Linking files together so the agent connects the dots 00:24:00 — Public-by-default culture, and what data they'd feed the brain 00:26:00 — Exposing the company brain to customers 00:28:00 — The "lethal trifecta" framing, and why the market isn't investing enough 00:30:00 — The scariest failure mode: exfiltration, not just leaks 00:32:00 — The wife/prompt-injection story 00:34:00 — Why the risk can't be zero — and the "blue worker suit" analogy 00:36:00 — Public Slack as a social guardrail against prompt injection 00:38:00 — Shopify's "River" and Tobi Lütke's Lehrwerkstatt 00:40:00 — Buy vs. build: is anyone doing this well already? 00:42:00 — An internal app store made of markdown files and PRs 00:44:00 — Will AI commoditize Kombo's own business? 00:46:00 — Why enterprise integrations resist commoditization 00:48:00 — Integration teams of 10–15 people, and Kombo's end-to-end bet 00:50:00 — Is SaaS dying? System-of-record inertia 00:52:00 — What actually changes vs. what doesn't 00:54:00 — Time travel: advice to his younger self 00:56:00 — Outro

Quotes:

00:17:29 – "The agent will just run a grep command and find 200 files where something is discussed, and it will actually look at 50 or so of them. It's not stopping too early." (verbatim) 00:24:26 – "We also share with employees the money in our bank account monthly. This is the kind of public-by-default that we run." 00:35:52 – "By having it in the Slack channel, our people see what the customer is doing with the agent, but also the colleagues of the customer see what's going on. That's reducing the amount of exploiting you can do, by a lot, just because other people have visibility." 00:32:14 – "My wife accidentally prompt-injected it without any bad intention. Now imagine people with bad intentions." (Tobi)

From HoloLens assembly to AI: Vaibhav Gupta on why LLMs need their own language, and how BAML makes them type-safe and shippable at agent speed.

BROUGHT TO YOU BY: Blocks

A decade building computer vision and writing assembly at Microsoft (HoloLens), Google, and D.E. Shaw, then a from-scratch bet on a programming language built for LLMs. Vaibhav Gupta joins Tobi to explain why probabilistic compute needs its own tooling, what "shipping at agent speed" actually requires, and why the world's appetite for software is mathematically infinite.

Chapters: 00:00:00 — Intro 00:01:00 — From HoloLens to D.E. Shaw: a decade in computer vision and assembly 00:02:00 — Starting from scratch, and the YC pivot ("500K to not build a Slack competitor") 00:04:00 — Falling in love with coding — and bricking a few machines along the way 00:06:00 — His first AI moment: the GPT-3.5 wake-up call 00:09:00 — Code as a means to an end — why 90% of the job is plumbing 00:11:00 — Why he decided to build a language: first principles and BAML 00:13:00 — LLMs as a new compute primitive 00:15:00 — What BAML actually is — embedded, type-safe, callable from any language 00:17:00 — The business model and the "data trench" 00:19:00 — When AI ships code you didn't ask for — and why CI/CD breaks in an agent loop 00:22:00 — Live demo: function versioning and locking the codebase 00:24:00 — Why no one else competes here — Protobuf, Thrift, and Google's playbook 00:29:00 — Getting started: the BAML "hello world" (live coding) 00:32:00 — Everything is a function — type safety that runs in Rust 00:36:00 — Shipping at agent speed = trust plus granular control 00:38:00 — Visualizing code instead of reading it 00:44:00 — Where to start with BAML (docs.boundaryml.com → Agents MD) 00:45:00 — The mathematically infinite appetite for software 00:47:00 — Why we'll have 10x more builders — and why "English isn't a programming language" 00:51:00 — The future of SaaS: PaaS, harnesses, and customer-defined models 00:56:00 — Will design matter more in an agent world? 00:59:00 — The "time travel" decorator: advice to his 2017 self 01:04:00 — Outro

Quotes: 00:13:00 — "BAML's a new thing that exists because we have a new compute primitive in the form of LLMs." (verbatim) 00:10:00 — "90% of software engineering — well, in most jobs, 100% of software engineering is plumbing… And AI just takes that 90%, just makes it go away." 00:19:00 — "We can now generate code at machine speed… But we still cannot ship code at machine speed." 00:49:00 — "English can't go down to assembly… And the minute you add that to English, what have you done? You've built a new programming language." 00:45:00 — "I don't think we've yet found a company that hasn't found that I can make more money if I write more code."

-- OUR SPONSORS

Blocks Save at least 20% on your AWS costs with AI-powered optimization and enterprise discounts. Get your free Cloud Check at blocks.cloud/alphalist.

ServiceNow's CTO of 20 years explains why the safest way to deploy AI agents is to treat them like employees, same rules, same approvers, same spending limits, and why AI is reshuffling the deck on who your best engineers are.

Intro How do you go from installing software off floppy disks to running engineering for a $13B revenue company — without ever losing the fish? Pat Casey, CTO of ServiceNow and its first engineer after founder Fred Luddy, joins Tobi to talk 20 years of scale, the architecture behind 90,000 databases, and why enterprise AI agents should be treated exactly like slightly untrustworthy employees.

Key topics

• Pat's nerd path: Atari 400, Wizardry, and building Adobe's first employee tracking system in Microsoft Access
• Flipping off Fred Luddy in traffic — and becoming ServiceNow employee-after-one
• The stuffed-fish code-ownership system and why productivity dips at ~100 engineers
• Inside the architecture: Java metadata engine, hacked Rhino, K8s services, single-tenant clusters
• RaptorDB: from MariaDB board seat to buying Swarm64 and forking Postgres
• Gen 3 of AI coding: Windsurf vs Claude Code, the 15% average vs the 5x outliers
• The five-chessboards theory of AI-native engineering, and Pat's daughter's vibe-coding conversion
• "AI Pat": agents in the user table, following human rules
• Hybrid pricing: seats for humans, consumption for AI
• Is the market wrong about SaaS incumbents? Pat's answer to the Anthropic scare
• What Pat would whisper to his younger self (spoiler: it's about Jelly XML — and family)

Chapters [00:00:51] Intro: who is Pat Casey [00:01:43] Nerd origin story: Atari 400, tape storage, Wizardry [00:04:12] First job at Aldus/Adobe — accidental ITIL [00:06:12] Flipping off Fred Luddy → joining Glide in 2005 [00:08:28] From 2 job titles to 10,000 engineers — the introvert advantage [00:10:21] The stuffed fish, and the productivity trough at 100 engineers [00:13:44] Architecture: metadata engine, Java monolith, Kubernetes [00:16:41] The single-tenant bet: 90,000 databases, 25B queries/hour [00:21:32] MariaDB, Monty, and building RaptorDB from Swarm64 [00:27:21] Postgres fork, OpenJDK contributions, open-sourcing Raptor? [00:29:35] AI coding gen 1–3: Copilot → 7,000 Windsurf licenses → Claude Code [00:33:35] Five boards of chess: who clicks with AI coding (and who doesn't) [00:36:47] Pat's daughter and the vibe-coding conversion [00:38:21] Enterprise agents: from toolkits to outcomes [00:40:41] "AI Pat": agents that follow human rules [00:42:29] Pricing: seats for humans, consumption for AI [00:46:15] The Anthropic scare, SaaS valuations, and the incumbent advantage [00:53:06] The new bottleneck: not engineering, not product — customers [00:59:00] Pat's advice to CTOs: lean in, don't turf it [01:01:26] Time machine: what Pat would whisper to his 2005 self

Quotes

[00:41:30] "You should not trust an LLM more than you trust a human being. Modern business processes were designed on the assumption that human beings are a little bit untrustworthy." (fillers removed — verify against audio) [00:34:00] "AI coding, if you get to that next level, is like playing five boards of chess, 'cause you got multiple prompts spinning at the same time." (one "um" removed) [00:16:04] "If it was that easy, none of the world's big monolithic code bases would still exist." (condensed from "It's like, all right, if it was that easy, like, none of…" — verify) [01:01:26] "This is not a time for excessive caution. It's not a time to completely go bonkers and do crazy stuff, but this is a time really to lean into the new technology." (one "uh" removed)

Anurag Goel was Stripe's fifth engineer before he built Render into a platform millions of developers deploy on. Here's his contrarian read on agents, security, and why "the AI cloud" is the wrong thing to be.

Show Notes

Anurag Goel joined Stripe as its fifth engineer in 2011 and later ran risk. He left to solve a big problem and landed on the one he'd watched eat Stripe's engineering time: making infrastructure disappear. This conversation is about what Render learned on the way to millions of developers and what changes now that a lot of what gets deployed isn't a website, it's an agent. * Key topics:*

From Stripe's fifth engineer to founding Render The "application cloud" vs. "AI cloud" positioning Agents as long-running, stateful applications for a new end user Workflows, sandboxes, and the consolidated AI runtime Executive hiring and reference calls as a growth hack Security: minimizing blast radius, short-lived scoped keys Distribution in the chatbot era (GEO) and why Google is underrated Observability is the real bottleneck for production agents

Timestamps

[00:00:00] Intro and the pitch [00:02:00] Origin story: ebook search engine, game rentals, and the first-ever Stripe payment [00:04:00] Joining Stripe as engineer #5; talent density [00:06:00] Raising the hiring bar, no warm bodies [00:11:00] Executive hiring and reference calls as a growth hack [00:13:00] Why he started Render: ~20% of Stripe's engineers stuck on AWS [00:16:00] Agents as a new kind of application [00:17:00] "We're the application cloud, not the AI cloud" [00:18:00] Workflows, sandboxes, and the consolidated AI runtime [00:24:00] Heroku's decline and the exploding sales pipeline [00:25:00] The agentic moment: when adoption spiked [00:33:00] Security and blast radius [00:50:00] Why SaaS isn't dying specialization [00:58:00] Distribution: from SEO to GEO [01:02:00] Why Google is underrated [01:03:00] Advice for CTOs going all in on agents [01:06:00] Easter egg: a whisper to his 2011 self

Max Deichmann built Langfuse — the open-source LLM engineering platform acquired by ClickHouse — and explains why the engineer of the future isn't writing code, they're reviewing what agents did overnight.

Max Deichmann didn't set out to build the observability layer for the AI era. He started with mobile apps, taught himself to code via Harvard's CS50, and ended up in Y Combinator with a SaaS product he wasn't excited about. Then ChatGPT launched, and on a Sunday night at 10 pm, his co-founder asked: "If you just had time, what would you build?" The answer became Langfuse and eventually led to an acquisition by ClickHouse. This episode is a rare, grounded conversation about what building and operating AI agents actually looks like in 2025, from the engineering loop to the 3 am incident, to what the engineer's job becomes when agents are doing most of the execution.

Key topics:

• Why LLM applications broke traditional observability tools, and what Langfuse does instead
• The pre-production → production → evaluation → iteration loop for agent development
• Open source as a trust and adoption strategy for dev tools
• The ClickHouse acquisition: why they sold, what the half-page doc said, and how it's going
• Agentic incident response: copy-pasting alerts into Codex at 3 am, and what comes next
• The "decision inbox" engineers are reviewers and decision-makers, not coders
• The real state of agents in production: what's working, what's not, and what LinkedIn gets wrong

Timestamps:

[00:00:00] Intro & guest welcome [00:02:00] Max's nerd origin story CS50 on a beach in Singapore [00:04:00] Why they pivoted to Langfuse: firing customers mid-YC batch [00:06:00] Building the first AI products and discovering the observability gap [00:07:00] What Langfuse actually does: the LLM engineering platform explained [00:09:00] Tracking business AND infrastructure metrics billing via Langfuse [00:10:00] Open source from day one: trust, adoption, and hardening the product [00:13:00] Go-to-market with 1.5 salespeople: how engineers sell to enterprises [00:14:00] The acquisition story: 5 engineers, 40TB/day, and a Series A that became a sale [00:17:00] What it felt like when half the AI ecosystem knocked on their door [00:18:00] Life inside ClickHouse: cultural fit, Tokyo offsite, and what surprised them [00:20:00] Agentic coding in practice: velocity per engineer, what still needs a human [00:22:00] The planning loop: Claude summarising GitHub discussions, RFC → agent → review [00:23:00] The "decision inbox" model: engineers as taste-makers and reviewers [00:27:00] How to build an observability stack for the agentic era from scratch [00:29:00] Agentic on-call: the 3 am Codex workflow and what's coming next [00:32:00] Where Langfuse fits vs. traditional observability agent quality vs. infra health [00:35:00] The real state of agents in production: the non-LinkedIn version

Best quotes:

"We didn't initially jump on the topic because we thought all the PhD AI people, they are much better at this. We have no idea what's going on, until we figured out nobody has a clue what's going on." — [00:05:00–00:06:00]

"We have two guys doing customer support, and we have basically an agent that is doing first-level customer support for us, and I think it's about doing about 10,000 conversations a week. We would never be able to do this type of support with two people." — [00:38:00]

"The alert comes in, I wake up at the night, I just take the alert from our Slack, copy paste it into Codex, and we have a skill there with all the context, and then it's just going." — [00:29:00–00:30:00]

"I currently think of an email/Linear inbox where an agent tells me, 'Hey Max, we needed to fix this here because this broke.' And then if I want to, I can just dive into it and see all the context within this notification and also take a corrective course, or I just let it go." — [00:41:00]

How a browser-based fix for an enterprise auth problem became a W3C web standard and what it means for how AI agents will interact with the web.

Alex Nahas, founder of MCP-B and initiator of the WebMCP web standard, joins Tobias to explore one of the most underappreciated shifts happening in AI: the browser as the primary runtime for agentic systems.

Key topics covered:

• What MCP actually is: an RPC framework for calling tools across processes, not the complex protocol it's made out to be
• The OAuth problem: why MCP's push towards OAuth locked out most enterprise infrastructure still running on SAML
• The WebMCP solution: running an MCP server in client-side JavaScript so agents can use the browser's existing auth context
• How a Hacker News post posted under anesthesia got 400 upvotes and caught the attention of Google and Microsoft
• Chrome 146 natively supports WebMCP, and what that means for adoption
• The chicken-and-egg problem: why website owners won't add WebMCP support until clients support it, and vice versa
• Agent identity: why agents don't need their own credentials and can operate as a subset of the user's identity
• Real-time bidding for agents: the emerging market where advertisers bid to inject results into agent contexts

- The agentic web in two years: headless browsers, intent-based interfaces, and agents that only surface the UI you need.

[~04:30] "The browser itself is like the perfect sandbox we've been iterating on for so long now." — Alex Nahas [~06:30] "MCP is just an RPC framework. It's super simple. Basically just a wrapper around API documentation." — Alex Nahas [~13:00] "My first memory coming back was me arguing with people on Hacker News who didn't understand it." — Alex Nahas [~16:30] "Agents don't need their own identity. They can have an identity that's like a subset of the user who spun them off." — Alex Nahas [~32:30] "This reminds him of the dawn of programming — where everyone was just doing things and nobody really knew what they were doing, but people were just trying to figure things out." — Alex Nahas [~43:00] "Believe in yourself." — Alex Nahas

Thirty years building search infrastructure — and why the AI industry quietly depends on it.

SHOW NOTES

Jean-Paul Schmetz has been close to search infrastructure for nearly three decades — as founder of Clix, the European search engine that eventually became part of Brave, and now as Chief of Ads at Brave Software. In this conversation with Tobi, he opens up the hood on one of the internet's most misunderstood infrastructure layers.

Key topics covered:

• The three independent search indices: why only Google, Bing, and Brave could answer every query on earth if the others disappeared
• How AI grounding works — and how most AI products are either paying for Brave Search API or quietly scraping Google
• The SERP API ecosystem: legal exposure, unit economics, and why Jean-Paul gives it a two-year shelf life
• Google's origin story: the NDA, the 120% revenue share strategy, and why they spent years pretending to lose money
• What it takes to build a search index from scratch — and why it's still a 10-year problem
• The Inktomi story: the $1M autocomplete investment no one else was willing to make
• Why Brave is profitable selling shovels to the AI gold rush — and what that looks like at $10M/month in infrastructure
• Agents and the web: why most people won't know what to do with 50 agents, just like they didn't know what to do with 50 employees
• What Jean-Paul would tell his 1996 self: think simpler, invest more aggressively, and stop underestimating capital

TIMESTAMPS: [to be added]

QUOTES:

[17:49] "Google was not better. It was just simply that they were driving you to queries they could answer better." — Jean-Paul Schmetz

[37:44] "There are more countries in the world that build atom bombs than countries that have a search engine." — Jean-Paul Schmetz

[49:08] "You're driving these Formula 1s with the wheels not properly attached." — Jean-Paul Schmetz

[01:28:45] "It's easy to appear intelligent when you list all the things that can go right, but it's much more courageous to actually claim what can go wrong." — Jean-Paul Schmetz

Fitness functions, agentic guardrails, and why experienced architects matter more than ever in the AI era

Show Notes: Neal Ford has spent decades thinking about how software systems hold together over time. In this episode, Tobias sits down with Neal to ask the question nobody is asking loudly enough: when AI agents write the code, who is responsible for the architecture?

We dive into:

-** Neal's origin story: **from journalism to mechanical engineering to computer science, and why writing made him a better architect

• **AI as an "advanced beginner": **why LLMs pattern-match instead of reason, and why that distinction matters deeply
• **Behavior vs. Capabilities: **the trap of building demos that scale to 60 users but collapse at 60,000
• **Architectural fitness functions: **how to use deterministic guardrails to constrain non-deterministic code generation
• Architecture Definition Language (ADL): using pseudocode to wire constraints into agents before they start building
• LLMs as interpolators: generating platform-specific fitness functions in Java, .NET, or Python from a single pseudocode spec
• **Legacy modernization: **why AI is best suited for re-engineering existing codebases, and what COBOL whispering looks like in practice
• Ephemerality as a new architectural dimension: the first question every CTO should ask before building anything
• **The future of developers and architects: **why experienced engineers are multiplied by AI — and 0 × 10 is still zero
• The AI hype cycle: RAD, no-code, and now agents — same pattern, same blowback, different speed
• Advice for CTOs: understand capabilities, govern what your agents build, and let life surprise you

Chapters: [00:00] Intro & welcome: Neal Ford — Software Architect & Author [00:28] Neal's journey: from journalism to computer science [02:10] Writing as a superpower in software architecture [03:45] AI as an "advanced beginner": the Dreyfus scale applied to LLMs [07:20] Behavior vs. Capabilities: the gap everyone is ignoring [11:05] Architectural fitness functions: guardrails for agentic systems [16:30] Architecture Definition Language (ADL) & LLMs as interpolators [21:00] Fitness function-driven architecture in practice [25:15] Legacy modernization: COBOL whispering and agentic re-engineering [30:40] Ephemerality: the new architectural dimension for CTOs [34:10] The future of developers, architects, and pull requests [38:50] The AI hype cycle: fads vs. trends [42:15] AI pricing models and the Silicon Valley playbook [44:30] Easter egg: choosing computer science over CIS — and why it paid off [46:00] Advice to his younger self: let life surprise you [47:10] Conclusion & final thoughts

Modernizing Yahoo in the private-equity era: legacy constraints, shipping velocity, and AI-native consumer products

Yahoo is far more than a nostalgia brand—it’s a broad consumer platform operating at huge scale. In this episode, Tobias sits down with Lee Zen (CTO @ Yahoo) to explore how the company is modernizing in the private-equity era, and what “innovation” looks like when you’re also responsible for decades of legacy systems.

We dive into:

**

• Yahoo’s consumer portfolio: Mail, Finance, Sports, News, Search—and what that implies for platform strategy
• What changes under private equity: priorities, focus, and modernization constraints
• Modernization in real terms: cloud adoption, legacy trade-offs, and sequencing big bets
• Shipping velocity as a leadership lever: faster learning cycles over perfect planning
• Organizational mechanics for rapid experimentation at consumer scale
• AI in engineering: where it helps, where it creates new bottlenecks, and “AI as a coworker”
• AI in the product (real use cases): mail catch-up, news key takeaways, finance and fantasy-sports insights
• The hardest problems at consumer scale: cost optimization, velocity, and quality without regressions
• Career reflections: imposter syndrome, self-belief, and staying hands-on as a CTO**

Chapters:

[00:00] Intro & welcome: Lee Zen (CTO @ Yahoo) [00:28] Lee’s journey & Yahoo’s evolution [01:14] Early computing: DOS, QBasic, and the builder origin story [03:43] Academic background: CS + AI foundations [05:20] Yahoo today: portfolio breadth & what private equity changes [08:54] Modernization: cloud, legacy constraints, and technical trade-offs [17:44] Leadership & org design: enabling speed and experimentation [22:52] AI integration: tool vs. coworker, and the future of engineering [31:38] AI across Yahoo’s consumer products: mail, news, finance, sports [32:21] Avoiding “AI labels”: enhancing UX with human + AI judgment [33:26] Consumer-scale engineering challenges: cost, velocity, and quality [34:28] Easter egg: side projects and reflecting on the past [35:34] Advice to his younger self: self-belief, self-love, imposter syndrome [36:28] Conclusion & final thoughts

Solving the "Outer Loop" bottleneck: Agentic coding, Stacked PRs, and the future of the CTO role with Graphite's Greg Foster

The "Inner Loop" of coding (typing syntax) has been solved by AI. The new bottleneck is the "Outer Loop"—reviewing, testing, and merging the flood of code that agents generate.

In this episode, Greg Foster (CTO of Graphite, now part of Cursor) explains why this shift drove their merger and what it means for the future of engineering.

We dive into:

• The Outer Loop Crisis: Why fast code generation breaks traditional review processes (and how to fix it).
• Agentic Engineering: The 2029 vision where engineers become "architects of agents" and writing code trends to zero.
• Stacked PRs: Why smaller, dependent changes are the only way to maintain velocity at scale.
• Metrics that Matter: Why "PRs per engineer" is actually a valid proxy for velocity (velocity = speed + vector).
• The Cursor Merger: Combining the best text editor (Inner Loop) with the best review platform (Outer Loop).
• Provenance in Git: The need for storing "prompts" and AI attribution directly in commit history.
• Advice to Young Engineers: Why understanding the business model is as important as reading O'Reilly books.

Chapters:

1. [00:00] Intro: Greg's journey from iOS apps to Airbnb infrastructure
2. [01:25] Graphite & The Pivot: Bringing "Phabricator-style" tools to GitHub
3. [03:52] Reinventing the Pull Request: Stacked PRs and Merge Queues
4. [13:20] The Velocity of Dev Tools: When Copilot/Cursor changed the game
5. [20:41] Metrics: Is "PRs per engineer" a vanity metric or a velocity proxy?
6. [24:22] Jevons Paradox: Why 2x productivity means more engineers, not fewer
7. [26:30] The Merger: Why Graphite joined Cursor (Inner + Outer Loop)
8. [33:30] Provenance: Storing AI prompts in Git history
9. [52:00] The 2029 Vision: Writing code -> Zero. Reviewing Agents -> 100%.
10. [56:17] Future of CI: Auto-generated sandboxes with agentic QA
11. [59:26] Advice to his younger self: Understand the business, not just the code