Mike, co-founder and CTO at Thundra, presents a solution that uses a vendor-neutral runtime intelligence layer and automated coding agents to continuously identify, optimize, and verify software performance issues in production, integrating human review to ensure trust and impact. He emphasizes the importance of precise context mapping, prioritization, and reliable automation to foster sustainable, agent-driven performance optimization without disrupting engineering workflows.
In this talk, Mike, co-founder and CTO at Thundra, addresses a common challenge in software engineering: performance issues that are recognized but not proactively investigated or fixed due to the unpredictable and often lengthy research phase. He highlights how teams frequently delay addressing slow pages or performance bottlenecks until they become critical, often relying on a single knowledgeable engineer. To tackle this, Thundra developed a runtime intelligence layer for coding agents that continuously captures detailed production context, enabling automated, agent-driven workflows to identify and optimize performance issues regularly without manual intervention.
Mike explains the technical foundation of their solution, emphasizing the importance of vendor-neutral infrastructure that supports various compute environments, models, and agents. They utilize GitHub Actions to run weekly automated analyses of production data, leveraging Cloud Code and runtime intelligence to generate detailed reports on performance bottlenecks. These reports, sent to communication platforms like Slack, highlight high ROI optimization opportunities grounded in real production context. The system not only detects issues but also proposes fixes, reruns tests to verify improvements, and presents these verified solutions to human reviewers, closing the feedback loop between automation and human oversight.
The talk also covers several challenges encountered during development, such as dealing with “plausible unverified” fixes where suggested changes seemed correct but failed in practice, handling complex queries in ClickHouse, and avoiding superficial “lazy fixes” that mask underlying problems. Mike stresses the importance of thorough methodology and accurate context, noting that production data often contains both too much low-signal noise and insufficient relevant logs or traces. To bridge this gap, they developed a “prod-to-code” approach that maps production metrics to function-level code context, enabling agents to reason precisely about where time is spent and what optimizations are feasible.
Further, Mike discusses the importance of prioritization and human factors in adopting automated fixes. Instead of overwhelming engineers with numerous pull requests, their system scores and surfaces only the most impactful and low-risk issues, presenting them in concise, human-readable reports. This approach respects engineers’ time and fosters trust in the automation by ensuring that flagged issues are genuinely worth addressing. He highlights that this hybrid model—automation augmented by human review—helps build a sustainable habit of continuous performance optimization without disrupting regular development workflows.
In conclusion, Mike shares key lessons learned: defining what matters through scoring and guardrails is crucial for reliable automation; agents can accelerate not just speed but also uncover opportunities that engineers might overlook; providing the right context and skills to agents enhances their usefulness; and achieving high confidence in automated fixes is essential for trust and adoption. He distinguishes agentic engineering automation from interactive coding assistance, emphasizing the need for 80-90% trust in autonomous systems. Mike encourages the audience to explore similar automations and expresses enthusiasm for ongoing innovation in AI-driven software engineering.