Dave is currently VP of Engineering at Astronomer, where he drives Reliability, Automation, and what he calls “general good sense across Engineering.” Before that: VP of Engineering at Twilio leading SRE, Sr. Director at Elastic building and scaling Elastic Cloud, and a 17-year career at Google (2004–2021) spanning SRE engineer to Engineering Director — including global lead for Storage and Databases SRE and head of Engineering at Google Ireland.

He authored Chapter 29 of the canonical Google SRE Book (”Dealing with Interrupts”), ran the first two Reddit AMAs ever done by Google’s SRE team, and has spoken at SREcon Europe multiple times (2015, 2021, 2022, 2023, 2024).

Dave isn’t a starry-eyed AI hype merchant. He comes from the discipline that has to clean up what the code generators leave behind — reliability, platform engineering, on-call. That’s a rare lens.

Timeline

01:49 — Capability outruns intent

02:28 — Expertise gets democratized

04:11 — Heuristics and T-shaped skills win

08:57 — Supply chain is about verifying, not trusting

12:22 — MTTR is overrated

21:19 — We’re in the pets.com phase

25:38 — “Good enough” beats “better”

41:42 — The dopamine and dissatisfaction trap

44:43 — The missed signal: providers get expensive

Share AI Builder Series

Summary

1. Capability is now unmatched with intent Dave’s central thesis: AI has handed teams enormous code-generation capability, but that capability has outrun judgment. People can build almost anything now, but few stop to ask whether they should. Operational and reliability teams are “bearing the brunt” downstream of all the decisions being made too fast.

2. The democratization of obscure expertise Operationally-focused teams historically guarded access and expertise, niche knowledge of YAML dialects, PromQL, obscure config languages. AI has democratized that “L1 cache” knowledge, so the value of being “the person who knows the config language” is collapsing. The monitoring guru should get ahead of it and find where they add value beyond rote knowledge.

3. Heuristics and T-shaped skills matter more, not less The mental models, problem decomposition, stakeholder management and architecture-level thinking, the “boring” translation of intent into capability, are becoming the crucial differentiators. The worry: the tech and remote-work shifts (like COVID) are disabusing junior engineers of the slog that builds senior judgment, making it unclear how the next generation matures.

4. Supply chain trust is a verification problem, not a trust problem “Trust” is the wrong frame. There’s no human in the loop to trust, just people abdicating the responsibility to verify. Incidents like the LiteLLM/Trivy vulnerabilities showed attackers acting in minutes (even mid-key-rotation), signalling that current methods of trusting software and doing incident response are breaking. He leans toward buying this capability (Chainguard, Cloudsmith) rather than every company building it.

5. MTTR is one of the least interesting metrics to optimize Driving down Mean Time To Recovery just plugs leaks faster while ignoring how many leaks you have. More interesting are mean time between failures and, crucially, postmortems aimed at systemic change so failures recur in novel rather than boring, repetitive ways. “Just get everyone to not do that” is a non-solution, since people churn and newcomers repeat the same mistakes.

Share AI Builder Series

6. You can’t turn everything to 11 Ask any CEO their target for SLOs, CVEs, customer satisfaction and they’ll say “100%, zero, perfect.” But security, reliability, and satisfaction can’t all be maxed simultaneously. It’s fundamentally a management trade-off requiring human judgment about how much the company actually cares about each vector.

7. We’re in the pets.com phase Dave draws a direct parallel to the late-90s dot-com boom: money is being thrown around to “see what sticks.” A reckoning will come, and what survives will be what’s foundationally useful to humans, just as Google emerged from the ashes by simply making things findable. His advice: “run towards the fire,” solve the genuinely hard problems that persist regardless of how AI shakes out.

8. “Is it good enough?” beats “Is it better?” The frontier models aren’t as architecturally different as marketing implies. Much of the differentiation is branding. With per-token pricing (e.g. Copilot’s shift, ~5x between cheaper and premium models) and examples like Harvey reportedly finding an open model far cheaper per task, the real question for businesses isn’t whether a model is better but whether it’s good enough for cheaper.

9. The dopamine and dissatisfaction problem Engineers became engineers to build and enjoy flow state. AI has replaced deep, single-problem focus with 10 to 15 parallel sessions and constant context-switching, and humans are “bad machines” at that. The output may be great but the experience is unsatisfying; people want to think about one problem for more than five minutes. Leaders must operationalize intent and teach the discipline of no, understanding what “non-work” is.

10. The signal people are missing: model providers are about to get expensive The big bet Dave sees coming: major providers will get significantly pricier, and how companies respond will define the next few years. He’s excited about self-hosting “good enough,” ring-fenced, focused models a company can own, and about the post-adjustment wave of genuinely human-centric products that filter noise, surface the one or two things worth a human’s judgment, and “make life easier” rather than pretending to converse and making you anxious.

Leave a comment

Sponsored by Kerno

Max has spent his career trying to understand how developers actually work — at Google, LinkedIn, and now Capital One, where he helps to set and drive the strategy for DevX enabling 14,000+ Capital One technologists to be efficient, effective, and happy with software development.

Podcast Timeline:
01:50 — Foundations of measurement: goals, proxies, and perverse incentives
10:54 — Measuring developer productivity in the AI era
14:47 — From power users to the whole team
23:07 — Building awareness, understanding, and a learning culture
29:10 — Advice for engineering managers and leaders
31:48 — The shifting pipeline: DevEx fundamentals and feedback loops
39:08 — The future: process, judgment, and expertise
48:42 — Closing thoughts: quality over velocity, and sign-off

Subscribe now

Takeaways from a conversation with Max on the AI Builder Series

1. Start with the goal, not the metric. The single biggest mistake teams make is grabbing off-the-shelf productivity metrics and bolting them onto a business they haven’t deeply understood. Every business is in a different state with different problems. “PRs per engineer” isn’t useless and it isn’t the answer — it’s one signal among many. The job is to triangulate from multiple imperfect proxies toward the truth.

2. Metrics improve developer experience. They don’t manage people. The moment a metric becomes a performance lever, it stops being useful for anything else. Engineers will split PRs into nonsense, spin up background jobs to burn tokens, and game whatever you point at them. You lose the diagnostic value of the signal and create perverse incentives in one move.

3. AI hasn’t changed what you care about. Only how you get there. The outcomes still matter: quality, reliability, customer impact. What’s changed is the process by which software gets built. So stop trying to correlate token usage to gross revenue. A business is a machine that produces results, and the machine matters.

4. Expect a dip before the lift. Every credible study shows productivity drops when teams first adopt agentic development. Leaders need to say, explicitly and out loud, “this is a time to learn and it’s okay to spend extra hours messing around with the agent.” Implication isn’t enough. ICs need permission.

5. Get resistant engineers over the line with a magical experience. Max’s go-to workshop: hand the team an incomplete spec for Rogue (the old text-based RPG), let them build it with Claude Code or Codex, then show off the results. The point isn’t to teach code review, it’s to recreate the feeling every engineer once had when they first told a computer to do something and it did it. That feeling is ten times stronger with agents. People want it back.

6. The fundamentals still win. The teams seeing the biggest lift from AI aren’t the ones with the fanciest agent rollout. They’re the ones who already invested in great testing, strong static analysis, automated guardraill, the unglamorous developer-experience basics. Agents amplify what’s already there.

7. Move feedback onto the developer’s machine. If validation only happens in a fifteen-minute CI run, agentic development doesn’t work. Max optimized his personal test suite from 30 seconds to 11 seconds because the agent runs it so often the difference is enormous. If you only do one thing to enable agentic software development, do this.

Share

8. Devs only code about 20% of the time. Go find the other 80%. Don’t solve it by mandating more coding. Investigate where the time actually goes, like outdated processes, unclear requirements, approval bottlenecks, product-side confusion. That’s where the real acceleration is hiding.

9. Where humans still matter: process, judgment, expertise. Agents are great at “I know the result I want, deliver it.” They’re bad at “here’s a process to build something nobody has seen before.” Scott Hanselman’s observation that Max quoted: people who clone Minecraft with an agent are letting the word Minecraft do all the heavy lifting. The further you get from “duplicate something that already exists,” the more your judgment matters.

10. The most underrated story right now: quality, not velocity. Everyone’s talking about how much faster software gets built with agents. Max thinks the real story is how much better it can get built. Writing great tests is easier than ever. Refactoring is easier than ever. Throwing away an hour of work and starting over is easier than ever. The opportunity isn’t quantity, it’s a level of craft we couldn’t reach before.

“Every time I have abandoned my judgment and expertise to the agent, I have only gotten myself into trouble. What I have yet to hear from anyone is: I looked at the code and decided I didn’t need to look at it.” — Max

Sponsored by Kerno

Founding & Early-Stage Lessons

Infovox was discovered almost by accident through a boutique dev shop the founders ran to pay the bills. Clients complained that nothing on the market properly solved high-volume document parsing, which became the idea. The same founding team had been building companies together for ten years, giving them faster market validation, existing networks, and hard-won lessons about what production-ready software actually requires. The pre-seed fundraise was brutal (100+ rejections) before getting funded through a Spanish crowd-investing platform, nearly missing payroll. Once they had some revenue (~€80-100k ARR), getting into YC followed.

YC & the Silicon Valley Effect

YC invests primarily in strong technical teams, often pre-revenue or even pre-product, so founders shouldn’t wait until they feel “ready.” The biggest advantage of Silicon Valley isn’t any individual perk; it’s the density of successful people around you constantly raising the bar for what you think is possible. Alberto sees European overregulation, particularly rigid labour law and unpredictable policy changes (e.g. Spain’s Verifacto e-invoicing regulation cancelled weeks before launch), as a genuine structural drag on startup growth.

AI Adoption Inside Infovox

About two years ago, Infovox mandated that every engineer must use AI tools (GitHub Copilot, Cursor, Windsurf, Claude Code) as an integral part of their workflow. About six months ago, with Claude Code specifically, they saw a step-change in what non-engineers could do. Now almost everyone at the company has a Claude Code account. Nightly AI agents review the CRM to flag things that fall through the cracks, and Alberto was initially sceptical but found it catches a surprising amount. Founders lead by example: build things, share them with the team, and circulate what other admired companies are doing.

The “Vibe Coding” Reality Check

The real cost of software is not building it; it’s maintaining it, fixing bugs, handling security issues, and keeping it running at scale. Simple, undifferentiated apps (e.g. a personal calorie tracker) are legitimately being disrupted by vibe coding, but anything requiring scale, accuracy guarantees, high availability, and learning from feedback remains genuinely hard. Alberto thinks it’s “insane” for non-CRM companies to vibe-code their own CRM. A CRM is not just a contacts table; it’s dialers, email sequencing, permission systems, and integrations. The complexity that emerges makes maintenance brutal, and paying for HubSpot is cheap in comparison. Jeff Bezos’s “focus on what makes your beer taste better” principle applies directly: everything that isn’t your core differentiator should be bought, not built.

Defensibility & the AI Market Shift

Infovox’s moat is accumulated expertise in accuracy at scale: how to measure quality, build self-improving pipelines, and process millions of documents reliably. The explosion of new software companies is actually good for Infovox, as more builders mean more potential clients who need document parsing. Infrastructure companies cannot afford the “push fast, break things” dynamic that consumer apps can get away with; reliability is the product.

The Signal Most People Are Missing

Outside the Silicon Valley/tech bubble, even sophisticated knowledge workers (doctors, consultants, engineers) think AI means ChatGPT. They don’t appreciate what’s actually possible today with agentic tools. What’s available now is already close enough to AGI-level capability that a single person in almost any knowledge domain can do things that were impossible one or two years ago. That gap between what’s possible and what most people know represents enormous opportunity for founders who can bridge it.

Brought to you by

Trust AI generated code. Ship with complete confidence.

Kerno moves behavior and integration testing from CI to the developers machine - creating an instant feedback loop between what’s been generated and what breaks, so agents fix sooner and create better code.

Up and running < 5 mins, available on CLI and IDE.

The Document parsing API for Developers

Timeline:

1:43 – How AI Creates Leverage for Startups
3:12 – Is AI Raising the Bar for MVPs?
7:39 – The "Nice Facade" Trap
9:15 – AI as an Investment Requirement
11:01 – Unit Economics & the Token Cost Problem
21:35 – Scaling a Unicorn With AI: The Seender Story
25:14 – AI Enablement Teams & the New Role of Engineers
28:05 – Getting Resistant Engineers On Board
36:21 – AI as Just Another Abstraction
40:04 – AI Security & the Non-Deterministic Risk

• AI Adoption at Enterprise

• Is paying Claude $1000/dev/month worth it?

• How AI is impacting how we report P&L

• What to take from the mobile first movement

• 2x2 Matrix on how engineering leaders should think about enabling everyone to ship

• Personal hardware and AI

This episode is sponsored by