13 Best Software Engineering Podcasts for Engineering Leaders in 2026

TLDR;

Engineering leaders in 2026 need podcasts built around real decisions, not industry chatter, the right show depends entirely on the problem you’re working on, not which one has the most downloads.

The 13 best software engineering podcasts for engineering leaders are: The Agentic Review, The Pragmatic Engineer, Latent Space, Dev Interrupted, Software Engineering Daily, CoRecursive, Lenny’s Podcast, The Changelog, Practical AI, Software Misadventures, StaffEng, The Engineering Leadership Podcast, and Software Engineering Radio.

Each show earns its slot for a specific audience: org design and Big Tech benchmarking, AI infrastructure decisions, developer productivity metrics, systems-level technical judgment, the product-engineering interface, and AI in the SDLC, The Agentic Review by Qodo is the only show currently analyzing what code quality and governance actually mean when agents write the code.

Finding the right software engineering podcast as an engineering leader in 2026 is harder than it should be, most lists haven’t kept up with how much the landscape shifted when AI coding agents entered the SDLC, and half the shows that dominated Slack recommendations three years ago have either gone quiet or drifted toward consumer tech news.

These 13 picks are for VPs of Engineering, Heads of Engineering, and senior tech leads who want something that sharpens a decision, not fills a commute. Every entry has a “best for” framing because the right show depends entirely on the problem you’re working on: a show essential for benchmarking org design delivers almost nothing to a staff engineer building systems-level judgment, and vice versa.

Key Takeaways

• The best software engineering podcasts for leaders split into two categories: ones that treat you as an engineer who happens to manage, and ones that treat you as a manager who used to write code. Know which you need.
• AI in the SDLC has generated a wave of new shows. Most are hype. Two or three are doing real engineering-first analysis.
• Depth per episode beats frequency. The shows on this list that publish less often consistently outperform the weekly-churn shows on signal per minute.
• Long-form formats (60 to 90 minutes) consistently bring up the decisions that didn’t ship, not just the ones that did.

Quick Reference: All 13 Best Software Engineering Podcasts at a Glance

The 13 Best Software Engineering Podcasts for Engineering Leaders

1. The Agentic Review: Best for AI in the SDLC and Code Quality Governance

Best for: Engineering leaders making decisions about AI in the SDLC ,  what governance looks like when agents write the code, what code quality means when no human read the diff, and whether the trust required to merge an AI-generated PR is actually earned or assumed.

The Agentic Review by Qodo is hosted by CEO and co-founder Itamar Friedman and AI Developer Relations Lead Nnenna Ndukwe. The show doesn’t do AI hype: the questions the hosts push guests on are the uncomfortable ones about what happens when teams stop reading the code their agents develop. 

Qodo, which produces the show, builds the code review and SDLC governance tooling that sits at this exact intersection, so the editorial lens stays grounded in what breaks in production rather than what looks good in a demo. 

Episodes include Scott Hanselman (VP at Microsoft) on why reading code still matters in the age of AI agents, Dexter Horthy (CEO of HumanLayer) on context engineering and lessons from a five-month experiment where a team stopped reading agent output and then had to rebuild from scratch, and Matthew Makai (creator of Full Stack Python) on agentic tools in production and sustaining architectural foundations against technical debt.

The thesis across episodes: typing code may be dying, but the SDLC, code review, and craft matter more than ever. Available on Apple Podcasts, Spotify, and YouTube.

What gets discussed:

• Why Scott Hanselman calls AI on a broken software lifecycle “a band-aid on cancer”: the SDLC has to be structurally sound before acceleration makes sense, and skipping that step compounds existing problems faster
• What Dexter Horthy’s team learned from five months of not reading agent-generated code: they ripped it all out and rebuilt by hand, and the recovery taught them that owning your context is not optional
• Why the uncanny valley of AI-assisted development, code that looks right but violates assumptions the agent couldn’t know, is harder to catch than obvious errors and demands different review processes
• How Matthew Makai frames architectural foundations as the primary defense against technical debt in an agentic environment: agents don’t preserve your abstractions, so governance has to do it deliberately
• Why review processes built for ten PRs a day will structurally fail at a hundred, as agents working overnight dramatically increase the PR volume engineering leaders wake up to

2. The Pragmatic Engineer: Best for Engineering Org Design and Big Tech Benchmarking

Best for: Engineering managers benchmarking their org’s decisions against how Big Tech and high-growth startups actually operate ,  headcount structure, on-call design, compensation bands, and technical migration decisions.

Gergely Orosz spent years as an engineering manager at Uber before building the most-read software engineering newsletter on Substack. The podcast carries the same register: specific, direct, and created by someone who has shipped code at scale. Episodes are long-form deepdives with experienced engineers and tech professionals sharing hard-earned lessons. 

Guests have included DHH, Martin Fowler, Charity Majors, Will Larson, and key maintainers of Linux and Rust. Orosz doesn’t do softball interviews: headcount numbers, migration horror stories, and compensation structures come up within the first ten minutes. By the end of 2025, the show crossed 10 million downloads. For a VP benchmarking team org design, it’s the clearest external reference currently running.

What gets discussed:

• How the Linux kernel’s trust model works and what it means for engineering orgs trying to maintain quality at scale, from the Greg Kroah-Hartman episode, the most-listened episode of 2025
• Why Netflix’s engineering culture gives senior engineers radical autonomy, what the “keeper test” actually involves, and how the lack of traditional management layers creates its own failure modes
• Why AI-fueled cheating has made remote algorithmic interviews unreliable as a hiring signal, and what companies are doing instead: in-person formats, AI-allowed problems, or redesigned take-homes
• How thoughtful software design matters more, not less, when AI generates code quickly, filling in decisions that engineers used to make deliberately (from the John Ousterhout episode)

3. Latent Space: The AI Engineer Podcast: Best for AI Infrastructure Decisions

Best for: Engineering leaders accessing AI infrastructure decisions ,  what model architecture choices mean for deployment, how inference engineering is formalizing as a discipline, and what the systems work inside frontier labs actually looks like.

Latent Space, hosted by swyx (Shawn Wang) and Alessio Fanelli, operates at the boundary between AI research and production engineering. The show reached over 10 million combined readers and listeners in 2025. Episodes go deep on inference optimization, agent architectures, retrieval-augmented generation, and the systems work required to run AI at production scale. 

Some of the most popular guests are researchers, ML engineers, and AI infrastructure founders working on actual hard problems rather than the demo layer. For an engineering leader deciding whether to build on top of a foundation model, fine-tune, or run inference infrastructure in-house, Latent Space provides the engineering-first analysis that most AI podcasts skip in favor of market commentary.

What gets discussed:

• Why frontier model performance is commoditizing and the durable enterprise advantage now sits in proprietary context: operational state, transaction logs, governed access, and feedback loops no competitor can replicate
• What happens when AI agents run businesses over long time horizons: Claude tried to report a $2/day vending machine charge to the FBI, revealing what production agent failure actually looks like
• Why AI security requires different threat models than traditional application security, since adversarial attacks that make agents leak credentials or call wrong tools don’t map to existing frameworks
• How inference engineering is formalizing into its own discipline with distinct skills from model training, covering token throughput optimization, GPU utilization, and latency management
• Why the enterprise data question has shifted from “where do we store it” to “how do we expose the right slice of state to an AI system at the exact moment it is doing work”

4. Dev Interrupted: Best for Developer Productivity Metrics and Team Health 

Best for: Engineering leaders who want operational metrics, team health, and org design insights from the people running engineering organizations at scale ,  DORA metrics, developer productivity measurement, and what actually gets reported to the board.

Dev Interrupted, created by LinearB and hosted by Andrew Zigler, Ben Lloyd Pearson, and Dan Lines, focuses on the decisions engineering leaders make: sprint planning philosophy, developer productivity measurement, incident review culture, and which metrics drive real outcomes versus which get mistaken for outcomes. 

The format is interview-driven with Heads of Engineering and VPs, and the questions stay operational. Recent episodes have covered the transition from traditional SDLCs to agentic development lifecycles, rising token costs forcing engineering leaders to prioritize strict business ROI, and why autonomous tooling is changing the daily workflow of developers in ways that metrics dashboards haven’t caught up with yet.

What gets discussed:

• Why developer productivity can go down as AI adoption increases: time saved in code generation gets reallocated to auditing and verification, a hidden tax that most dashboards don’t measure
• How Honeycomb’s CEO Christine Yen frames the AI codebase problem: the codebase is no longer the source of truth, production is, and observability has to become the primary way leaders understand their systems
• Why the transition to agentic development requires a productivity context engine rather than better AI models, and what that distinction means when evaluating tooling investments
• How LinkedIn deployed agentic platforms across a massive org: what the rollout sequence looked like, where resistance appeared, and how adoption was driven without mandating it
• Why the “hero mindset” in engineering teams is a structural problem that DORA metrics can surface, and what Fix-It Weeks look like when used to change workflows rather than generate dashboard data

5. Software Engineering Daily: Best for Infrastructure Breadth and Back-Catalog Research 

Best for: Heads of Engineering who need breadth ,  a show that covers infrastructure, security, developer tooling, and emerging platforms at a consistent technical level and functions as a searchable back-catalog for specific topic research.

Software Engineering Daily has published daily episodes since 2015. The format is an interview-driven technical briefing with practitioners: database architects, platform engineers, security researchers, and founders of developer tooling companies. 

The signal-to-noise ratio across daily volume is uneven, but the back-catalog across hundreds of episodes on distributed systems, observability, API gateway architecture, and infrastructure topics makes it genuinely useful as a research tool rather than purely a listening show. 

For an engineering leader who wants to stay current on the full breadth of the infrastructure and tooling environment without reading a dozen newsletters, the daily format is more efficient than it sounds once you treat the feed as searchable.

What gets discussed:

• How platform engineering is shifting from building internal tools to running internal products with roadmaps and adoption metrics, and what that requires from the engineers who lead those teams
• Why open-source AI model adoption carries a different risk profile than closed APIs: licensing ambiguity, security review overhead, and the operational cost of maintaining inference infrastructure yourself
• How the MCP protocol achieved wide adoption where previous interoperability standards stalled, and what those ecosystem dynamics tell leaders about which standards are worth building integrations for
• Why observability is becoming the distinguishing capability in AI-augmented codebases, where production behavior increasingly diverges from what any reviewer read in the diff before merge

6. CoRecursive: Coding Stories – Best for Systems-Level Technical Judgment 

Best for: Staff engineers and senior technical leads who want to develop the kind of historical and systems-level judgment that informs good architectural decisions ,  how real systems were built, what broke, and why the lessons didn’t travel.

Adam Gordon Bell’s CoRecursive is one of the most underrated shows in software engineering. Each episode is a long-form narrative: not a conversation about a topic, but an account of a specific system, bug, or architectural choice told by the person who lived through it.

Episodes have covered the history of Unix, the engineering decisions behind software that ran for decades before anyone documented it, the origins of CPAN and its influence on every package manager that followed, and what it looked like building inside Apple from 2001 to 2015. For an engineering leader developing the pattern recognition that underpins good technical judgment, CoRecursive gives something trend-focused shows don’t: depth that ages well.

What gets discussed:

• How CPAN became the first open-source package repository in 1995 and seeded the design decisions behind npm, Maven, Cargo, and PyPI, with the lesson that trust was always a harder problem than distribution
• What 14 years inside Apple’s engineering org looked like: top-secret project staffing, development plans changed by Jobs mid-cycle, and what tight deadlines teach about organizational risk tolerance
• How Douglas Crockford discovered JSON and why his battle against XML was really a battle for simplicity as a design value, with implications for every API decision a team makes today
• How Adam Jacob built Chef into a widely adopted DevOps tool while dealing with imposter syndrome as a sysadmin-turned-startup-CTO, and what the gap between technical credibility and leadership confidence looks like from the inside
• Why Spotify’s platform team decision to build around transparency rather than control changed the relationship with product engineers who depended on them, and how that played out operationally over years

7. Lenny’s Podcast: Best for the Product-Engineering Interface

Best for: Engineering leaders who operate at the product-engineering interface and want to understand how the other side of the table thinks ,  roadmap prioritization, technical debt as a product decision, and why eng and product keep misaligning.

Lenny Rachitsky’s podcast sits at the exact intersection where engineering leadership and product strategy overlap. Guests are product managers, founders, growth engineers, and engineering leaders from companies like Figma, Notion, Linear, and Stripe. 

The episodes most relevant to engineering leaders are the ones on roadmap prioritization, technical debt framed as a product decision, and how eng and product teams build or fail to build trust. Lenny has a specific skill for pulling out the actual decision-making process rather than the cleaned-up version that makes it into the case study. Gergely Orosz of The Pragmatic Engineer has appeared as a guest, which gives the crossover a useful reference point for listeners of both shows.

What gets discussed:

• Why technical debt conversations between eng and product stall: engineering leaders frame it as risk, product leaders frame it as cost, and neither framing alone gets it onto the roadmap
• How Linear keeps engineers and designers close to product decisions rather than receiving requirements from PMs, and what that demands structurally from engineering leadership
• Why Stripe puts engineers directly in customer conversations rather than passing interpreted requirements downstream, and what that requires from a VP of Engineering managing those relationships
• What growth engineering looks like as a discipline separate from product engineering: different time horizons, different incentive structures, and why mixing them without intention creates compounding friction
• How VP of Engineering and VP of Product disagreements actually resolve in practice, and why the answer depends more on who owns the customer relationship than on the technical risk assessment

8. The Changelog: Best for the Open-Source Ecosystem

Best for: Engineering leaders who need to stay current on the open-source ecosystem ,  what’s being built, who’s funding it, and what the governance and maintenance reality looks like behind critical OSS projects your org depends on.

The Changelog has been publishing since 2009, making it one of the longest-running developer podcasts on this list. The flagship show covers open-source projects, developer tooling, and the people building the infrastructure the broader industry runs on. 

For an engineering leader analyzing build-versus-buy decisions, assessing open-source dependencies, or understanding the sustainability of projects their org relies on, The Changelog provides context that vendor documentation doesn’t. The Changelog network also runs Ship It (infrastructure and DevOps) and JS Party (JavaScript ecosystem) for leaders who want vertical depth on top of the flagship show.

What gets discussed:

• How open-source project governance works at the maintainer level: who makes decisions, how burnout propagates through a contributor graph, and what signals a dependency is heading toward unmaintained
• Why the funding model behind a critical OSS project (foundation, corporate sponsor, individual donations) creates different incentives and risks that engineering leaders should assess before treating it as a long-term bet
• How MCP won wide adoption in 2025 where previous interoperability standards stalled, and what those dynamics tell leaders about which standards are worth building integrations for
• What the decline of Stack Overflow means for engineering orgs that built onboarding processes around it, and what teams that have adapted are using to replace it

9. Practical AI: Best for Briefing Non-Technical Stakeholders on AI

Best for: Engineering leaders who need to brief non-technical stakeholders on AI ,  a show that stays technical enough to be credible while remaining accessible enough to use as a reference when explaining AI decisions up to the C-suite.

Practical AI, hosted by Daniel Whitenack and Chris Benson and created by Changelog Media, covers applied machine learning and AI tooling for practitioners who aren’t AI researchers. The format is accessible without being shallow: guests are engineers and researchers who have deployed AI in production, and conversations stay close to implementation details and failure modes rather than capability claims. 

Recent episodes have covered Anthropic’s Zero Trust for AI Agents security framework, the shift from traditional OCR to language-vision document models, and what Steve Klabnik (known for his work on Rust) found when he moved from AI skeptic to building a programming language largely with Claude. For an engineering leader who regularly translates AI decisions upward, Practical AI provides the grounded framing that holds up in a boardroom conversation.

What gets discussed:

• What Zero Trust for AI Agents means operationally: the key security risks, which controls matter most when an agent makes tool calls autonomously, and how traditional cybersecurity principles need to evolve
• Why 30% of developers report little to no trust in AI-generated code, and what that trust gap means for teams trying to show that AI adoption is improving delivery outcomes rather than just throughput
• How document processing has evolved from OCR to language-vision models, and why the gap between prototype accuracy and production accuracy is larger than most teams anticipate before deployment
• What Steve Klabnik found building a programming language almost entirely with Claude: where AI accelerated the work and where confident wrong answers cost more to fix than writing from scratch
• Why AI can solve prestigious math competition problems but still fails at tasks requiring physical or organizational context, and what that specific gap tells leaders about where AI tooling creates false confidence

10. Software Misadventures: Best for Postmortem Culture and Early Management Track

Best for: Engineering managers early in the management track who want to hear about technical failures and organizational dead ends without the survivor-bias filter that most retrospectives apply.

Software Misadventures, hosted by Ronak Nathani and Guang Yang, is explicitly about the things that went wrong. Guests are engineers, founders, and investors who recount incidents, failed product launches, architectural dead ends, and organizational problems that took longer than expected to come up. 

The show has featured Kelsey Hightower on influence without authority, Simon Willison on LLMs as “weird, overconfident interns,” and the engineers behind Airflow and Superset on what project-community fit in open source actually requires. Most episodes run past 90 minutes. For an engineering manager starting to own postmortems and incident culture, hearing how others navigated the same situations is more useful than another episode about what to do when everything goes right.

What gets discussed:

• How Simon Willison’s “weird, overconfident intern” model works: LLMs have read all the documentation, always think they are right, and code is going into production that its own authors don’t fully understand
• Why Kelsey Hightower frames startup advising as influence without authority: how to add real value when you have no decision-making power, and what passive versus active advising looks like in practice
• How Oxide Computer solved the “N+1 shithead problem” with transparent, uniform compensation, what performance reviews look like when everyone is paid the same, and why comp secrecy creates organizational dysfunction
• What Oxide’s founders learned shipping the first server rack: the false summits, writing their own manufacturing software, and why “missing just enough context to be optimistic” is both a risk and a prerequisite

11. StaffEng: Best for Hearing How Staff Engineers Actually Think

Best for: Engineering leaders building or retaining a staff engineering track ,  what the staff-level job looks like day-to-day, how staff engineers build organizational influence without direct reports, and where the role breaks down across different company types.

The StaffEng podcast, hosted by David Noël-Romas and Alex Kessinger and inspired by Will Larson’s staffeng.com research, interviews staff engineers, principal engineers, and distinguished engineers across different company types. 

The show recently rebooted around a sharper focus: practitioners using AI to ship concrete outcomes, with specific examples rather than general observations. For an engineering leader whose senior ICs are asking where the career goes next, or who is building a staff engineering track that doesn’t function as a management consolation prize, StaffEng provides the most direct external reference on what the role actually involves.

What gets discussed:

• What it looks like to not have opened an IDE since late 2025, from a staff engineer at Stripe: how the physical workflow of writing code has changed and what that means for skill development at senior levels
• Why “bespoke” has become the term for hand-written code in 2026, and what that semantic shift signals about how engineering culture is revaluing human judgment relative to generated output
• How staff engineers are navigating AI adoption: evaluating tools they didn’t build, justifying tooling decisions to leadership, and maintaining standards when code volume outpaces review capacity
• Why staff engineers are now having security and governance conversations with HR business partners and non-technical stakeholders they never had to engage with before

12. The Engineering Leadership Podcast: Best for the Engineering Manager to VP Transition

Best for: Engineering managers moving into VP-level roles who want structured frameworks for organizational design, hiring strategy, retention, and managing upward.

The Engineering Leadership Podcast, created by the Engineering Leadership Community (ELC) and hosted by Patrick Gallagher, is squarely about the management track. Episodes cover how to structure engineering organizations, how to hire and retain senior engineers in a constrained market, how to manage the relationship with product and design, and how to build an engineering culture that survives hypergrowth. 

Guests are engineering leaders rather than individual contributors, and conversations stay at the org-design level rather than the implementation level. For a senior engineering manager preparing for a VP role, the show is the most directly relevant on this list for that specific transition.

What gets discussed:

• How effective leadership looks different across product-led, business-led, and design-led orgs, and why an approach that works at one type actively fails at another (from Sebastiano Armeli, who held roles at Meta, Spotify, Snap, and PayPal)
• Why AI is moving engineering managers from implementation oversight to architectural governance, and what new skills and failure modes that transition introduces
• How the next bottleneck in AI-augmented engineering orgs is managing high-velocity experimentation overhead rather than code production pace, and what that means for sprint planning
• What fractional CTO work, advising, and coaching look like as career alternatives to the traditional VP track, and which skills from the management track actually transfer
• Why the identity tension between IC and manager doesn’t resolve at the staff or VP level, and how the most effective leaders hold both identities rather than choosing between them permanently

13. Software Engineering Radio: Best for CS Fundamentals and Architectural Rigor

Best for: Senior engineers moving into leadership who want rigorous technical grounding in computer science fundamentals, systems design, and software architecture ,  the gaps left by fast-paced startup environments.

Software Engineering Radio, created by the IEEE Software team, is the most academically rigorous show on this list. Episodes cover type systems, distributed consensus, formal verification, and software testing theory, with guests who have spent careers on these problems rather than shipping a SaaS product. 

The format is long and technical. For an engineering leader who came up through a high-velocity startup environment and wants to close gaps in foundational CS knowledge, Software Engineering Radio does it without condescension and without treating rigor as a blocker to practical application.

What gets discussed:

• How distributed consensus works at the implementation level: the gap between understanding Raft conceptually and understanding the failure modes that appear in production under partial failure or network partition
• Why formal verification is moving from academic research into practical tooling, and where the cost-benefit calculation tips in favor of verifying system properties before deployment rather than testing them after
• How Rust’s type system enforces correctness properties at compile time that would otherwise require extensive runtime testing, and what that tradeoff means for choosing languages for long-lived infrastructure
• What software testing theory says about coverage percentages as a metric: why they are a weak proxy for actual risk reduction and what a stronger testing strategy looks at instead

Conclusion

The podcasts that actually serve engineering leaders in 2026 share a quality that’s harder to find than it sounds: they treat the audience as people who are working through real decisions, not as an audience for vendor positioning or hype cycles. The Pragmatic Engineer does this for org design and Big Tech patterns. CoRecursive does it for technical history and systems judgment. The Agentic Review does it specifically for the AI-in-the-SDLC decisions that every engineering leader is navigating right now. If you add three shows to your rotation from this list, start with The Pragmatic Engineer, CoRecursive, and The Agentic Review, and add from the list based on where your current gaps are.

Frequently Asked Questions

Which software engineering podcast is best for VPs of Engineering?

The Pragmatic Engineer is the strongest choice for VPs of Engineering because Gergely Orosz consistently covers organizational decisions, team structure, compensation, and technical strategy at the level where VP-level tradeoffs actually happen. Dev Interrupted and The Engineering Leadership Podcast are strong complements for the operational management side.

Are there good podcasts specifically about AI coding tools and code quality?

The Agentic Review is the most engineering-focused show currently covering AI in the SDLC. “Qodo, which produces the show, builds code review and SDLC governance tooling, so the editorial point of view stays close to real workflow decisions rather than AI capability announcement. Latent Space covers the deeper AI infrastructure and model engineering layer.

What software engineering podcasts are worth listening to for staff engineers?

StaffEng is the most directly relevant for staff and principal engineers. CoRecursive is excellent for the systems-level and historical technical judgment that staff engineers develop over time. The Pragmatic Engineer covers staff-level perspectives as well, specially in episodes with guests like Martin Fowler and engineers from companies running complex distributed systems.

How do I find software engineering podcasts that aren’t just interview shows with the same guests?

CoRecursive and Software Misadventures both take formats that differ from the standard interview circuit. CoRecursive focuses on narrative storytelling about specific systems and decisions, while Software Misadventures explicitly seeks out the failure stories and postmortems that don’t make it onto conference talk slides. Both create content that doesn’t circulate in the usual guest-swap pattern.