In this episode, we sit down with Rohan Katyal and Raghav Sethi, co-founders of Milana, to discuss the shift from passive analytics to the world’s first AI Product Engineer. Rather than just providing another dashboard to monitor, Rohan and Raghav are building an agentic partner that you add to your product to bridge the gap between discovery and deployment. Drawing on their experience at Meta, Yelp, and Airtable, they explore how Milana enables autonomous improvement - turning deep user intelligence into shippable code and structural refinements that act as a tireless extension of your engineering team.

The conversation dives into why session replays — a mature but historically underused technology — are now a powerful data asset thanks to vision LLMs. Raghav explains how session replays are really just high-granularity logging of DOM changes, not screen recordings, and why feeding them through AI unlocks insights that traditional event-based analytics simply can’t capture. The team breaks down how they use just-in-time structuring to extract meaning from dense, unstructured session data without requiring upfront instrumentation.

Rohan shares hard-won lessons from building Yelp’s experimentation platform — including how teams that simply ran more experiments consistently outperformed those with better data resources. They discuss the tension between A/B testing rigor and iteration speed, why most experiments never ship, and how lowering the cost of generating and testing hypotheses changes everything about product development velocity.

We also get into the technical details of semantic clustering across millions of sessions, why video is actually a more compact representation than raw DOM for LLM reasoning, and how Milana analyzes sessions from multiple perspectives — user researcher, PM, founder — to surface real pain points. Plus, a bold prediction: analytics dashboards are dying, and the future belongs to agentic systems that don’t just deliver insights but actually own and drive your OKRs.

Topics covered:

• Why session replays are the ultimate untapped data asset for product teams
• How vision LLMs unlocked AI-powered analysis of user sessions
• Just-in-time data structuring: querying unstructured sessions without upfront instrumentation
• Lessons from building experimentation platforms at Yelp and Airtable
• Why running more experiments beats having better data
• Semantic clustering: separating signal from noise across millions of sessions
• Video vs. DOM vs. events — the best data representation for LLM reasoning
• Analyzing agent behavior through session replays
• The death of dashboards and the rise of agentic growth systems
• User research horror stories and the surprising things users do

Chapters

00:00 Introduction to Rohan and Raghav's Journey
04:47 The Importance of User Research
08:03 Making Solutioning a Science
11:09 Understanding Session Replays and Experimentation
14:50 Defining Sessions and Experimentation Platforms
18:54 The Need for Consistent Metrics
22:11 The Role of Events vs. Session Replays
29:46 Leveraging LLMs for Enhanced Insights
35:04 Determinism vs. Non-Determinism in Data Analysis
37:57 Understanding User vs. Agent Behavior
39:47 The Art of Structuring Data
45:25 Semantic Clustering and Its Importance
47:09 Building Infrastructure for Complex Data
51:24 The Future of User Simulation and Experimentation

Jamie, a seasoned startup founder and former Dropbox engineer, shares insights on building distributed systems, scaling storage solutions, and the impact of AI on infrastructure and application development. Discover practical lessons from scaling Dropbox, the evolution of data storage, and how Convex is shaping the future of app development.

In this episode, we sit down with the full founding team of Wild Moose — CEO Yasmin Dunsky, CTO Roei, and VP R&D Tom Tytunovich — to explore how they’re transforming production debugging from an art into a science using AI.

The trio shares their unconventional founding story — from meeting across three different cities to living together for three months in a California Airbnb to stress-test both their idea and their relationship. They discuss how they identified production debugging as a massive unsolved problem before ChatGPT even launched, recognizing that while code generation is fundamentally a text problem, debugging is a search problem that demands a completely different approach.

We dive deep into Wild Moose’s “microagents” architecture — fast, highly optimized AI agents that replicate the muscle memory of senior engineers to automatically investigate production incidents in under a minute. The team explains why accuracy trumps everything in their space (wrong answers are worse than no answers when you’re debugging at 3 AM), how they navigate the speed-cost-quality triangle, and why they built a test-driven approach to validate agents against past incidents.

We also get into the multi-agent vs. single-agent debate, handling multimodal observability data (logs, metrics, traces, dashboards, code), and how the rapidly evolving LLM landscape creates both opportunities and challenges for production AI systems. Plus, the team shares their favorite outage war stories — including a “WatchCat” hack and a three-month hunt for a single rogue bit.

Topics covered:

• The Wild Moose origin story and the California Airbnb experiment
• Why production debugging is a search problem, not a text generation problem
• Microagents: fast, specialized AI agents for incident investigation
• Building institutional knowledge into AI — capturing engineering muscle memory
• The speed-cost-quality triangle in real-time AI systems
• Multi-agent vs. single-agent architectures: when to use what
• Handling multimodal observability data with LLMs
• The future of AI SRE and self-healing production environments
• Favorite outage war stories from the trenches

Chapters

00:00 Introduction to the Wild Moose Team
04:12 The Spark Behind Wild Moose
08:41 Understanding the Debugging Landscape
12:45 The Role of AI in Debugging
17:31 Building Investigative Agents
21:55 Optimizing Workflows and Feedback Loops
29:12 Navigating Complexity in Software Systems
33:42 Adapting to Rapid Changes in AI Technology
40:02 Microagents: The Future of AI Architecture
44:46 Outage Stories: Lessons from the Trenches
50:49 Vision for the Future of AI in Production

In this episode, Hussain shares the story behind xorq: a “lockfile for ML pipelines” that makes notebook work easier to reproduce, debug, and ship. We talk about why the research→production path is still so manual, how schemas (and Arrow) become the contract between systems, and what it takes to run the same pipeline across engines like Snowflake and Databricks. We also dig into escape hatches for imperative code, why feature stores didn’t become the default, and how xorq fits alongside other technologies like Iceberg.

Chapters

00:00 Hussain's Journey in Data Science

06:00 The Need for xorq: Bridging Research and Production

10:38 Challenges in Machine Learning Deployment

17:40 The Role of Lock Files in Data Pipelines

29:51 Understanding Schema Management in Data Systems

34:40 Navigating Declarative and Imperative Transformations

36:39 The Developer's Journey with xorq

38:34 Feature Stores vs. xorq: A Comparative Analysis

43:43 The Future of Feature Stores and Machine Learning

51:41 Reproducibility in Data Pipelines: xorq vs. Git-like Operations

55:47 The Future of xorq and the Data Ecosystem

Summary

In this episode of Tech on the Rocks, Kostas and Nitay sit down with Wes McKinney the creator of pandas and co-creator of Apache Arrow and Ibis, and long-time leader in the Python data ecosystem. Wes walks us through his journey from building pandas in 2008 to rethinking how we represent and move columnar data with Arrow, and why Arrow is fundamentally different from file formats like Parquet and ORC.

We get into the future of data file formats, DataFusion and the new generation of query engines, the rise of open data lakes (Iceberg, Delta, Hudi), and why “big metadata” is becoming just as important as big data. Wes also shares candid thoughts on open source sustainability, how companies and infrastructure projects really survive, and how AI coding agents like Claude Code are changing the day-to-day work of software engineers, especially for complex systems work.

If you care about the foundations of modern data infrastructure, or you’ve ever called import pandas as pd, this is an episode you won’t want to miss.

Chapters

00:00 Intro — Wes McKinney & his journey in the Python data ecosystem

02:15 How pandas evolved & why UX first mattered for data science

06:14 Open source sustainability, funding & the Posit model

07:31 From pandas to Datapad, Cloudera & the origins of Apache Arrow and Ibis

13:38 What is Apache Arrow? In‑memory columnar data, batches & schemas

22:23 Inside Arrow IPC — zero‑copy, Flatbuffers & cross‑language interop

24:34 Arrow vs Parquet — columnar memory format vs columnar storage format

29:28 The next generation of columnar file formats & GPU‑friendly encodings

36:03 Big metadata, table formats & the rise of Iceberg/Delta/Hudi

43:05 Rethinking data systems: from big data to DuckDB, Rust & “no JVM” stacks

54:11 DataFusion as a modular Rust query engine for modern startups

57:58 Open source, the composable data stack & why infra is “AI‑resistant”

01:00:07 Vibe‑coding with AI agents — using Claude Code in real projects

01:09:49 AI, open source maintainers & the risks of AI‑generated contributions

01:18:57 Bridging LLMs and data: ADBC, data context & the future of infra + AI

Summary

In this conversation, the founders of Bauplan, Jacopo and Ciro, share their extensive backgrounds in AI and data infrastructure, discussing the evolution of NLP and the challenges faced in the industry. They highlight the importance of data pipelines in AI effectiveness and the complexities of building data infrastructure.

The discussion also covers lessons learned from previous ventures, the shifting dynamics of the AI market, and the need for collaboration between data scientists and engineers. They emphasize the significance of simplicity in data tools and the future of data management focusing on standardization and accessibility.

In this episode

• Bauplan was founded by experienced professionals in AI and data.
• Data challenges remain significant despite advancements in AI.
• Lessons from previous ventures inform current strategies.
• Building data infrastructure is complex and requires careful planning.
• Collaboration between data scientists and engineers is essential.
• Data engineering will resemble more and more software engineering.
• Simplicity in data tools can enhance user experience.
• The future of data management will focus on standardization and accessibility.

If you care about making AI features shippable by regular software teams—not just data specialists—this conversation maps the terrain and the trade-offs.

Chapters

00:00 Introduction to Bauplan and Founders' Background
02:27 The Evolution of NLP and AI Challenges
05:05 Shifts in Data and AI Application
07:56 Lessons from Previous Ventures
10:20 The Search Market Landscape
13:05 Behavioral Data's Role in Search
15:52 Building Data Infrastructure vs. Applications
18:22 The Complexity of Data Management
21:03 Bridging the Gap Between Data Science and Engineering
23:39 Challenges in Infrastructure Development
29:52 Navigating the Infrastructure Landscape
32:19 The Pendulum of Centralization and Decentralization
34:00 The Need for Standardization in Data Infrastructure
36:52 Simplifying Data Workflows
40:29 Radical Simplicity in Data Management
45:28 Overcoming Resistance to Change
48:50 The Future of Data Abstractions and Git for Data

Summary

Brett — founder & CEO of Micro — joins Nitay and Kostas to share how he’s turning email into a knowledge graph and rebuilding CRM right inside the inbox. He traces a path from Google’s M&A and Allo product team to Clearbit and Launch House, then digs into why most “inbox zero” workflows fail, how interoperability and AI agents shift power to the interface, and what it takes to design an email experience people actually live in.

What you’ll learn

• Why email is a system of record—and how Micro converts threads into people, companies, attachments, tasks, and “updates”
• The wedge: founders’ real workflows (fundraising, hiring, sales) and why CRM belongs in the inbox
• Product & UX lessons: skeuomorphic first, flexible theming (consumer vs. enterprise), and copy-the-UI-before-evolving-it
• M&A realities from Google: talent vs. tech vs. business acquisitions, and why culture kills most deals
• Burnout and agency: why founders report less burnout than big-company roles
• The next phase: cross-app “updates” (email, LinkedIn DMs, etc.), Salesforce/HubSpot read–write, and agentic automation

Chapters

00:00 Brett's Journey: From Consulting to Tech Innovator

02:41 The Role of Strategy in Tech Companies

05:16 Understanding M&A: Successes and Failures

07:55 The Evolution of AI in Corporate Strategy

10:26 Transitioning to Product Management

13:19 Lessons from Clearbit: Culture and Growth

15:50 The Impact of Burnout on Career Choices

18:15 Finding Fulfillment in Entrepreneurship

21:09 Navigating the B2B Landscape

23:34 The Necessity of Products in a Crisis

33:24 The Unexpected Layoff and New Beginnings

34:39 The Launch House Experience

37:16 Transforming Reality into an Accelerator

39:17 The Evolution of Founders and Content Creation

41:52 Introducing Micro: A New Email Experience

47:02 Extracting Information for Better Workflows

53:49 Integrating with Existing Ecosystems

01:01:16 The Future of Email and AI

Summary

Steve Klabnik has spent the last 15 years shaping how developers write code—from teaching Ruby on Rails to stewarding Rust’s explosive growth. In this wide-ranging conversation, Steve joins Kostas and Nitay to unpack the forces behind Rust’s rise and the blueprint for developer-first tooling.

• From Rails to Rust: How a web-framework luminary fell for a brand-new systems language and helped turn it into today’s go-to for memory-safe, zero-cost abstractions.
• Community as UX: The inside story of Cargo, humane compiler errors, and why welcoming IRC channels can matter more than benchmarks.
• Standards vs. Shipping: What Rust borrowed from the web’s rapid-release model—and why six-week cadences beat three-year committee cycles.
• Three tribes, one language: How dynamic-language devs, functional programmers, and C/C++ veterans each found a home in Rust—and what they contributed in return.
• Looking ahead: Steve’s watch-list of next-gen languages (Hylo, Zig, Odin) and the lessons Rust’s journey holds for anyone building tools, communities, or startups today.

Whether you’re chasing segfault-free code, dreaming up a new PL, or just curious how open-source movements gain momentum, this episode is packed with insight and practical takeaways.

Chapters

00:00 Introduction and Personal Connection
00:59 Journey from Ruby on Rails to Rust
02:21 Early Programming Experiences and Interests
07:20 Community Dynamics in Programming Languages
13:59 The Importance of Community in Open Source
14:37 How Ruby on Rails and Rust Built Their Communities
21:44 Standardization vs. Unified Development Models
30:55 Community Debt in Programming Languages
36:24 Release Cadence vs. Feature Development
37:36 Rust's Unique Selling Proposition
43:30 Attracting Diverse Programming Communities
52:31 The Future of Systems Programming Languages