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.