Will Larson traces how zero-interest-rate hiring culture reshaped engineering management, then argues that leaner organizations and AI tools are restoring technical judgment to the center of leadership. The longtime CTO also maps a less conventional path to executive roles, where line managers and hands-on engineers may have an edge over career bureaucrats.

Uber veteran Uday Kiramendisethi traces the company’s internal developer stack from homegrown systems such as Michelangelo and Cadence to AI gateways, guardrails and agent-ready cloud workspaces. The conversation examines how faster builds, shared tools and global operational complexity shape engineering productivity at scale.

Microservices pioneer Sam Newman argues that distributed systems demand fewer absolutist architectures and more honest choices about failure, customer impact and operational limits. He also weighs production as the ultimate source of truth and warns that AI can erode the shared understanding software teams need.

Cockroach Labs CTO Peter Mattes traces a career through GIMP, Gmail’s storage systems and distributed databases, with B-trees recurring as a durable engineering obsession. He also makes the case that AI coding agents can raise output without sacrificing rigor, provided engineers force them to test, measure and review relentlessly.

Maggie Appleton traces how an anthropologist turned design engineer thinks through software’s human context, from paper sketches to agent-built prototypes. She argues that good design lives in the tension between technical constraints, cultural taste and the cognitive limits of the people using the product.

Matt Pocock traces his path from voice coach to TypeScript educator and AI-skills creator, arguing that agents make software’s old strategic disciplines newly urgent. His GrillMe and Wayfinder tools use relentless questioning, shared language and decades-old programming wisdom to steer AI away from entropy.

Codex lead Thibault traces the coding agent’s path from OpenAI’s infrastructure work to an open-source Rust harness, arguing that agentic software development shifts attention from code review toward intent, contracts and architecture. He also describes how cheap maintenance and re-architecture are remaking the pace of engineering inside OpenAI.

Casey Moratori challenges the industry’s acceptance of sluggish software, arguing that performance begins with architectural choices, hardware literacy and theoretical limits rather than late-stage profiling. He also considers AI coding tools’ unsettled effects on engineering craft and autonomy.

Former Chrome engineering director Addy Osmani traces his path from building a browser as a rural Irish teenager to shaping DevTools and Core Web Vitals at Google. He also weighs how AI agents are remaking software work, leaving engineers responsible for judgment, verification and accountability.

Charity Majors argues that AI’s boosters and skeptics are responding to real evidence: faster code generation on one side, worsening reliability and operational strain on the other. The Honeycomb co-founder makes the case for replacing faith in code review with production feedback loops, observability and stronger validation.

Formal methods consultant Hillel Wayne argues that mathematical verification remains too costly for most day-to-day software, even as AI makes specification work easier at the margins. The conversation ranges from why software engineers resemble other engineers more than they admit to how tools like TLA+ and Alloy expose rare concurrency and distributed-systems bugs that ordinary testing misses.

A wide-ranging AMA traces Gergely Orosz’s shift from Uber manager to independent publisher, then circles through AI hiring, code quality, startup culture and the engineers still finding leverage in a choppy market. Along the way, he argues that AI is less a doctrine than a tool, and that careers are future-proofed less by credentials than by proximity to relevant work.

Rob Ayers traces how deployment practices evolved from weekly release boards to progressive delivery, arguing that feature toggles, roll-forwards, and platform teams do more to reduce risk than ritualized rollbacks. The conversation also untangles GitOps beyond its name, surveys Kubernetes at enterprise scale, and considers how AI-driven code velocity may shift CI/CD from speed toward safety.

Dak Sarada, co-founder of OpenCode, talks about scaling an open-source coding tool to millions of users while resisting the fantasy that AI automatically makes teams faster or products better. The conversation circles the unglamorous work of taste, cleanup, and restraint, along with the economics of inference and the GPU bottlenecks shaping the AI boom.

Alice Real traces Rust’s rise from forum culture and async infrastructure to Android and the Linux kernel, arguing that the language’s strict rules buy reliability in exchange for a steeper learning curve. The conversation digs into ownership, borrow checking, governance by committee, and why memory safety has turned Rust from an enthusiast’s tool into an institutional one.

Anders Hejlsberg traces the accidents, lawsuits, and internal battles that shaped Turbo Pascal, C#, and TypeScript, from Java’s legal fallout to Microsoft’s uneasy embrace of open source. The conversation doubles as a philosophy of language design: tooling matters as much as syntax, AI still needs deterministic systems beneath it, and great developer platforms are built on decade-long bets.

Mario Zechner and Armin Ronacher trace the rise of AI coding agents from hobbyist frustration to workplace reality, arguing that self-modifying tools can be powerful while also making software flimsier, reviews harder, and open source harder to steward. Their conversation lands on a broader unease with an industry chasing frictionless speed, even as good engineering still depends on bottlenecks, judgment and the memory of pain.