Try BAML: https://www.boundaryml.com/eap
As AI generates more of our code, reading every line is quickly becoming impossible. So how do you understand systems you didn't write?
In this episode, Dex and Vaibhav argue that observability is no longer just an operations tool—it's becoming the foundation for modern AI engineering. They explain why traces matter more than logs, why understanding execution is more valuable than reading source code, and how rich telemetry gives both humans and agents the context they need to debug complex systems.
The bigger lesson is that observability isn't about collecting more data. It's about building engineering systems that make unknown problems easy to investigate. From wide events and distributed tracing to visualizing execution and designing better feedback loops, the team outlines a practical framework for understanding increasingly autonomous software.
KEY TAKEAWAYS
AI-generated code demands new ways to understand software
Observability shifts debugging from guessing to investigating
Rich traces become the foundation for reliable AI systems
Wide events capture the unknowns you'll need later
Visualization helps engineers understand systems without reading every line of code
Good telemetry creates better feedback loops for both humans and agents
Tracing should be designed into software—not added after the fact
The future of debugging is understanding execution, not just implementation
SUMMARY
Modern software is changing faster than engineers can realistically read it. As AI generates larger portions of a codebase, understanding systems requires a new mental model—one built around observing execution instead of inspecting source code.
Dex and Vaibhav argue that observability has evolved from an operations concern into a core engineering discipline. Rather than treating logs, metrics, and traces as monitoring tools, they explain how rich telemetry provides the context needed to understand non-deterministic AI systems. Wide events, distributed traces, and structured execution data allow engineers to investigate problems they couldn't have anticipated when the software was written.
The discussion expands beyond debugging into software design itself. The team demonstrates how execution traces reveal system behavior without requiring engineers to read thousands of lines of generated code, making it easier to identify bottlenecks, visualize architecture, and build stronger intuition about how applications actually behave in production. As AI agents become responsible for larger portions of development, those same traces also become the foundation for agent-driven debugging and faster iteration.
The central idea isn't to stop understanding code—it's to understand it differently. By designing applications with observability from the beginning, engineers gain a reliable way to reason about increasingly complex systems while giving AI agents the feedback they need to investigate failures, learn from production behavior, and improve software over time. Observability becomes less about monitoring infrastructure and more about creating a shared source of truth for both humans and machines.
TIMESTAMPS
Why AI Changes the Way We Read Code
Introducing Agent Observability
AI Engineering After the Hype
Why Observability Starts With First Principles
Building Confidence Without Reading Every Line of Code
Why User Trust Depends on Observability
Why Metrics Alone Aren't Enough
From Metrics to Modern Observability
Observability Is Built for Unknown Problems
Finding Bugs by Following the Trace
Tracing Every Layer of Execution
Logs, Metrics, and Traces Explained
Building Better Feedback Loops With Tracing
Why Agents Need Rich Execution Data
Designing Observability for Humans and AI
The Cost of Rich Observability
Why Tracing Belongs Inside Your Application
Building Observability Without Reinventing
Understanding Code Without Reading It
Every Layer Needs Observability
Designing Systems You Don't Have to Read
TOPICS COVERED
Agent observability
Distributed tracing
Telemetry
Software observability
AI-generated code
Logs, metrics, and traces
Debugging
Feedback loops
AI engineering
Software architecture
Developer tooling
Tracing systems
LINKS
Website: https://www.boundaryml.com
Docs: https://docs.boundaryml.com
GitHub: https://github.com/BoundaryML/baml
HASHTAGS
#AIThatWorks #AIEngineering #Observability #DistributedTracing #SoftwareEngineering #DeveloperTools #CodingAgents #Telemetry #ArtificialIntelligence
Transcript
I've watched this one closely. Ask me anything about it and I'll point you to the exact moment.