Overview of Observability and human intuition in an AI world
This live Stack Overflow Podcast episode from HumanX explores how AI is changing observability, software validation, and production reliability. The first half features Christine Yen, CEO of Honeycomb, who argues that AI is collapsing the software development lifecycle into a faster “validation” loop where the key question becomes: Did the code do what we intended? The second half features Spiros Zantos, CEO of Resolve.ai, who focuses on how AI agents can help SREs and developers manage the growing burden of production incidents created by AI-generated code. Across both conversations, the central theme is that trust, guardrails, and clear definitions of “good” matter more than ever.
Christine Yen: Observability in the age of AI
AI is compressing the software lifecycle
Christine describes a shift from discrete stages like spec, implementation, review, and testing toward a much tighter loop where humans and agents are increasingly just “builders.” In this world, observability, testing, and CI all converge around a single concern:
- Did the system behave according to intent?
- Can we validate outcomes quickly and reliably?
- Can we do that without relying on humans reading every line of code?
Telemetry is still just data — but it should reflect what matters
Her definition of telemetry is intentionally practical: it’s the “bits and exhaust” an application emits so you know it’s doing something. She pushes back on debates over logs vs. traces vs. metrics and instead emphasizes:
- Capture the signals that matter for your business
- Shape telemetry around the service you actually run
- Use metadata and context to make the data useful
- Define what “good” means before optimizing for it
Business outcomes are becoming part of observability
Christine argues that the most valuable telemetry increasingly connects directly to business goals and user outcomes. For example:
- E-commerce teams care about checkout flow, carts, SKUs, and latency
- Social platforms care about uploads, relationships, likes, and user IDs
- Financial systems care about availability, reliability, and low latency
In other words, KPI thinking is moving closer to telemetry.
Durable vs. disposable code
She distinguishes between:
- Disposable code: internal tools, toy apps, quick experiments where efficiency and longevity don’t matter much
- Durable code: systems where performance, reliability, and guardrails are critical
AI-generated code doesn’t change the requirements for durable systems; it just makes it more important to define those requirements upfront.
Trust, guardrails, and non-determinism
Christine says AI introduces more non-determinism into software development, which means observability needs to capture not just outputs but also the decision-making context behind those outputs. She sees the future as one where:
- Debugging shifts into telemetry-first investigation
- The “source of truth” moves away from code alone
- Trust becomes a core product and UX concern
- Teams must decide where agents can act freely and where they need well-worn paths
Spiros Zantos: AI SREs and production operations
AI code generation increases operational load
Spiros frames AI-generated code as a force multiplier that makes software creation easier, but also increases the amount of code that must be supported in production. He points out that production work was already expensive before AI:
- Teams spent huge amounts of time maintaining production systems
- Engineers had to glue together multiple tools and data sources
- Debugging incidents was already a painful, human-heavy process
AI just makes this problem bigger.
Resolve.ai as an AI agent layer on top of observability
Spiros positions Resolve as a general-purpose AI agent for production systems, not a replacement for observability. Observability remains one of the key tools, but the agent also uses:
- Code
- Architecture
- Documentation
- Infrastructure context
- Human knowledge
The goal is to help humans respond to incidents faster and reduce the stress of constant production firefighting.
Context is the real challenge
He emphasizes that production systems are different from codebases because context is scattered, incomplete, and often outdated. AI systems need to:
- Discover missing context
- Make that context explicit
- Operate across multiple tools and data sources
- Work like a team of specialists, not a single monolithic bot
Security and controls must be stricter than ever
Spiros warns that autonomous agents touching production need very high safety standards. He compares:
- A simple robot vacuum, which has limited blast radius
- A self-driving car or production agent, where safety must be proven before autonomy is acceptable
His view is that AI agents should be able to:
- Take action
- Write code
- Create tools dynamically
- Respond to incidents quickly
But only with strong controls, compliance, and security guardrails.
Human SREs are still needed
He does not see AI replacing SREs. Instead, he expects humans to move:
- From “in the loop” to “on the loop”
- Toward oversight, policy, and high-level judgment
- Away from repetitive incident handling
His prediction: within about 12 months, agents may resolve 80–90% of incidents.
Key takeaways
- Observability is shifting from infrastructure signals to outcome validation.
- AI is making intent, trust, and guardrails more important than raw code volume.
- Telemetry should increasingly reflect business value, not just system internals.
- Durable systems still need performance, reliability, and safety, even if code is AI-generated.
- AI agents will likely become major tools for incident response and production operations.
- Humans will remain essential for defining “good,” setting boundaries, and overseeing autonomous systems.
Notable themes
What “good” means matters more than ever
Both guests repeatedly return to the idea that AI forces teams to define success more carefully. Whether you’re generating code or operating production systems, the critical question is no longer just Can we do it faster? but Did we solve the right problem, in the right way, with the right safeguards?
Trust is the real currency
AI can accelerate development and operations, but it also introduces uncertainty. The future of observability and SRE, as described here, depends on making systems more transparent, more measurable, and more trustworthy.