When code gets cheaper to produce, feedback becomes the limiting factor - CI, reviews, and the handoffs between tools can quietly slow everything down.

Rob Zuber breaks down what platform engineers are seeing as teams adopt AI-assisted development: more branch builds, new failure modes, and growing pressure to shorten the loop between “change made” and “change validated.” He focuses on how CI can evolve from a human-first dashboard into a system that agents can interact with directly through APIs, CLIs, and MCP-style interfaces - so fixes can happen faster and with less waiting on manual triage.

Along the way, Rob and Cory dig into practical questions engineering leaders are wrestling with: how PR review becomes the next major bottleneck, what “agent experience” means in a delivery pipeline, why speed isn’t only about faster compute (it’s also about doing less unnecessary work), and how teams can share learnings so “agentic velocity” doesn’t only benefit a few power users.

If you’re building or running the systems that ship software, this is a clear look at where CI fits in an AI-accelerated workflow, and what needs to change to keep delivery safe, fast, and sustainable.

Guest: Rob Zuber, Chief Technology Officer at CircleCI

Rob Zuber is a 20-year veteran of software startups, a four-time founder, and three-time CTO. Since joining CircleCI, Rob has seen the company through its Series F funding and delivered on product innovation at scale while leading a team of 300+ engineers who are distributed around the globe.

CircleCI, Website

CircleCI, LinkedIn

CircleCI, GitHub

Links to interesting things from this episode:

• “The Confident Commit” podcast
• Wardley Mapping
• “How one programmer broke the internet by deleting a tiny piece of code.”

A lot of infrastructure and automation fails for ordinary reasons: rate limits, flaky networks, partial permissions, long-running jobs, and retries that vanish when the process restarts. Durable execution is a way to design systems that keep going anyway - without rebuilding a maze of queues, cron jobs, and manual cleanup.

Cornelia Davis breaks down how durable execution works in practice: writing “normal” code while the runtime provides durable retries, state management, and the ability to pause work, wait for a human or external change (like a quota increase), and resume right where things left off. The conversation connects these ideas to platform engineering realities - Terraform workflows, long provisioning times, and “orphan” resources - and explains how Temporal workflows and activities help teams model failure handling as a first-class part of the system.

You’ll also hear why this approach is showing up in AI engineering: long-running agent workflows, frequent rate limiting, and the need to avoid re-running expensive LLM calls when something breaks near the end.

Guest: Cornelia Davis, Developer Advocate at Temporal Technologies and author of “Cloud Native Patterns”

Cornelia Davis is a Developer Advocate at Temporal, where she brings more than three decades of experience as a software technologist to help engineers build resilient, scalable systems. Known for her pragmatic blend of hands-on coding, technical strategy, and customer collaboration, Cornelia is passionate about helping developers unlock the full potential of modern cloud-native architectures. Previously, she served as VP of Technology at Pivotal, where she played a key role in shaping Cloud Foundry and enabling enterprise cloud transformations. Whether she’s writing code, presenting at conferences, or whiteboarding with teams, Cornelia is driven by a singular goal: empowering developers to build better software. Outside of tech, she recharges on the yoga mat or in the kitchen, where she brings the same creativity and focus to her practice.

Temporal, Website

Temporal, GitHub

Temporal Community, GitHub

Temporal’s AI-assisted development tools

Links to interesting things from this episode:

• Temporal Developer Skill
• “Cloud Native Patterns” by Cornelia Davis

What happens when a non-deterministic AI system is asked to touch production telemetry or generate changes for an SRE pipeline? The cost of being “close enough” can be lost data, downtime, or a security incident.

Cribl’s Nikhil Mungel joins Cory to break down what it takes to build AI that sysadmins can actually trust. The conversation digs into harness engineering and the practical guardrails that turn probabilistic models into repeatable, verifiable outcomes. They cover why breaking work into small chunks matters, how validation and testing become the real leverage point for AI-native development, and what “code factories” mean for review, CI, and platform reliability when teams can generate a thousand PRs an hour.

Platform engineers will also hear a pragmatic take on the future of the job. The focus shifts away from typing code and toward building systems for verification, simulation, and safe deployment at scale, plus clearer ways to decide what needs human scrutiny and what can ship automatically.

Guest: Nikhil Mungel, Head of AI R&D at Cribl

Nikhil Mungel is the Head of AI R&D at Cribl, where he's building LLM-powered systems for IT and Security data transformation and analysis. Before Cribl, he spent over a decade developing distributed systems across the observability and consumer social tech landscape. He lives in San Francisco with his wife and two kids. His current focus is applying AI to make complex infrastructure more intuitive and explainable.

Nikhil Mungel, Website

Nikhil Mungel, X

Cribl, Website

Cribl, LinkedIn

Links to interesting things from this episode:

• Cribl Guard
• “Open source died in March. It just doesn't know it yet.” by Dan Lorenc, CEO of Chainguard

When a flaky test can stall a merge queue, “just rerun CI” stops scaling fast.

Cory talks with Trunk co-founder and CEO Eli Schleifer about the outer loop problems that show up as teams ship more code - especially with AI-assisted development increasing PR volume. They break down what a merge queue is, why logical merge conflicts happen even when individual PRs are green, and how predictive testing helps protect main without forcing constant retesting.

Eli also explains how Trunk approaches flaky tests: collecting JUnit results, using quarantines so known flakes don’t block delivery, and fingerprinting failures to tell the difference between “this always times out” and “this was just broken by a recent change.” The conversation closes on how review and quality practices may shift as code generation accelerates - and what still needs strong guardrails like tests, security checks, and reliable CI signals.

Guest: Eli Schleifer, co-founder and CEO of Trunk

Eli Schleifer leads Trunk’s technical vision and product strategy, focused on closing the gap between AI-speed code generation and human-speed delivery by removing the bottlenecks that slow modern engineering teams. Trunk’s platform eliminates flaky tests, resolves merge queue constraints, and redesigns CI systems to enable high-throughput, continuous delivery.

Prior to founding Trunk, Eli was CTO at Directr, which was acquired by Google, and has served in engineering leadership roles at YouTube, Uber, and Microsoft.

Eli Schleifer, X

Trunk, website

Trunk, Slack

Trunk, Github

Trunk, X

Links to interesting things from this episode:

• Balsamiq
• “Code First Engineering” by Eli Schleifer

Billions of requests a month on AWS Lambda can cost less than a single engineer’s laptop budget, but only if the architecture and developer workflow are designed for it.

Justin Masse, Senior Platform DevOps Engineer at Extend, shares how Extend committed early to a serverless-first approach and built a platform that prioritizes developer speed and low operational toil. The conversation breaks down what it takes to run active-active, multi-region systems in a serverless world, how the team keeps services small and fast, and why asynchronous, event-driven design changes both reliability and cost.

You’ll also hear how Extend treats developer experience as a core platform responsibility: templated microservices, fast deployment pipelines, ephemeral environments for pull requests, and infrastructure that developers can own without becoming cloud specialists. A big theme is using AWS CDK and internal abstractions to keep infrastructure close to the application code, so teams can move quickly while keeping platform standards consistent.

Finally, the discussion gets practical about tradeoffs that show up after the “serverless is easy” pitch: local development challenges, the real cost center (observability), and where AI is helping today, including an internal agent that diagnoses failed deployments and suggests fixes.

What you’ll learn

1. Why Extend avoids servers and VPC complexity, and what they use instead
2. Patterns for active-active, multi-region thinking in a serverless architecture
3. How DevEx practices like templates and ephemeral environments reduce friction
4. A pragmatic approach to IaC with CDK and reusable internal constructs
5. Where serverless costs stay low, and why observability often dominates the bill
6. How AI is being applied to platform workflows without skipping engineering judgment

Guest: Jusin Masse, Senior Platform DevOps Engineer at Extend

Justin Masse is a self-proclaimed lead chaos engineer, recognized within niche engineering communities for his expertise Chaos Engineering and Infrastructure & DevOps.

The father of three young kids, a husband, a recent MBA graduate, recent cancer survivor, and competitive powerlifter, he still finds time to actively contribute to the platform engineering community.

Justin Masse, website

Justin Masse, GitHub

Extend, website

Links to interesting things from this episode:

1. Episode with Adrian Cockroft
2. “From $erverless to Elixir” by Cory O’Daniel

What happens when nobody wrote the code running in your production environment? As AI-generated software becomes standard practice, platform engineers face a new challenge: operating systems without experts to consult.

Nic Benders, Chief Technical Strategist at New Relic, has spent 15 years watching observability evolve from basic server monitoring to understanding complex distributed systems. Now he's tackling the next frontier: how to maintain and operate software when there's no human author to ask why something was built a certain way.

The conversation covers the shift from instrumentation being the hard problem to understanding being the bottleneck. Nic explains why inventory matters more than you think, how to approach AI-generated code as a black box that needs testing and telemetry, and why "garbage in, safety out" should be your new mantra.

You'll learn practical strategies for instrumenting modern systems with OpenTelemetry, why your observability hierarchy needs to start with knowing what's actually running, and how to build platforms that make safe deployment easier than risky shortcuts. Nic also shares his perspective on technical drift versus technical debt and what changes when your best troubleshooting tool - institutional knowledge - no longer exists.

Whether you're drowning in observability data or just starting to instrument your systems, this conversation offers concrete approaches for building understanding into your platform engineering practice.

Guest: Nic Benders, Chief Technical Strategist at New Relic

Nic Benders is New Relic's Chief Technical Strategist. Part of the Engineering team since the early days of the company, Nic has been involved with everything from Agents to ZooKeeper and all the pieces and products in between. As New Relic's Chief Technical Strategist, he now looks after the long-term technical strategy behind the product and the experience of all the engineering teams who build it. Before New Relic, he worked in the mobile space, managing back-end messaging and commerce systems powering some of the largest carriers in the world.

New Relic, website

New Relic, Blog

Links to interesting things from this episode:

1. OpenClaw (aka Moltbot, aka Clawdbot)
2. Moltbook