12 Best Developer Podcasts Worth Your Time in 2026

I started listening to developer podcasts in 2016. Back then there were maybe a dozen worth following. Now there are hundreds. Most of them are bad. Not offensively bad, just forgettable. They read release notes at you, or they interview someone who gives the same generic advice you've heard on every other show. "Just build projects!" Thanks, never heard that one before.

The podcasts on this list are different. These are the shows I actually queue up every week. The ones that have changed how I think about code, career decisions, and the industry. Some are technical deep-dives. Some are career-focused. A couple are pure entertainment that happens to make you smarter. I tried to balance the list between shows for newer developers and shows for people who've been building software for years.

One thing you'll notice: I care more about consistency than production value. A podcast that drops a great episode once a quarter isn't useful. The shows below deliver every single week (or close to it). That reliability is what makes podcasts such a powerful learning tool. You're not making a one-time investment. You're building a habit that compounds over months and years.

1. Syntax

Hosts: Wes Bos and Scott Tolinski

Episode length: 30 to 60 minutes. New episodes twice a week. Over 900 episodes in the catalog.

What it covers: Full-stack web development. JavaScript, TypeScript, CSS, React, Node.js, databases, deployment, developer tooling, and whatever's new in the web ecosystem that week.

Why it's number one: Wes and Scott have the best chemistry of any developer podcast duo. They've been doing this since 2017 and they still sound like two friends geeking out about code over coffee. That matters because technical content gets dry fast, and these two keep it engaging without dumbing anything down. Their "Hasty Treats" episodes (shorter format) are perfect for commutes. The longer deep-dives on topics like "Modern CSS in 2026" or "Server Components Explained" are genuinely educational. What sets Syntax apart is the format variety. They do Q&A episodes, "Supper Club" interviews with industry guests, opinion-heavy "Tasty Treats," and structured tutorials. You never get bored because the format keeps rotating. They also aren't afraid to have opinions. When Wes thinks a tool is overhyped, he says so. When Scott changes his mind about a framework, he explains why publicly. That honesty makes the advice trustworthy.

Best for: Web developers at any level. If you write JavaScript for a living, this is non-negotiable.

Where to listen: syntax.fm or any podcast app.

Pro tip: Their annual "predictions" and "year in review" episodes are some of the best on the show. They grade their own predictions honestly, which gives you a realistic picture of how the industry actually moves versus how people expect it to move.

2. The Changelog

Hosts: Adam Stacoviak and Jerod Santo

Episode length: 60 to 90 minutes. Weekly episodes. Running since 2009.

What it covers: Open source software, developer culture, the people behind major projects, and the intersection of technology with the real world.

Why it made the list: The Changelog is the NPR of developer podcasts. It's thoughtful, well-researched, and consistently excellent. Adam and Jerod don't just ask "what does your tool do?" They ask "why did you build it this way? What went wrong? What would you do differently?" Those questions produce answers you can't get from documentation or blog posts. The show has a unique ability to make you care about projects you've never used. I've listened to episodes about niche database engines and obscure programming languages and walked away genuinely fascinated. That's rare. The broader Changelog network also runs focused shows like JS Party and Go Time, so if you like the main show's vibe, there's a whole universe of content to explore. What makes The Changelog especially valuable is its historical perspective. When a new trend hits (AI coding, edge computing, whatever), Adam and Jerod connect it to patterns they've seen over 15 years of covering open source. That context helps you separate real shifts from temporary hype.

Best for: Developers who care about the open source ecosystem. Anyone who wants to understand the people and motivations behind the tools they use daily.

Where to listen: changelog.com/podcast or any podcast app.

Pro tip: The Changelog's "News" episodes (released weekly as a separate feed called Changelog News) give you a five-minute summary of the most important open source stories that week. Subscribe to that feed separately for a quick weekly briefing you can listen to while making coffee.

3. Software Engineering Daily

Hosts: Originally Jeff Meyerson, now Gregor Vand and Sean Falconer

Episode length: 45 to 60 minutes. Nearly daily episodes. Over 1,500 episodes in the archive.

What it covers: Everything in software. Cloud infrastructure, databases, DevOps, machine learning, frontend frameworks, distributed systems, startups, and emerging technologies.

Why it made the list: The sheer volume of Software Engineering Daily is its superpower. With nearly daily episodes covering a different topic, it functions less like a podcast and more like an always-on professional development feed. You won't love every episode. That's fine. The point is that when you need to learn about a specific technology or concept, there's probably an SE Daily episode covering it with a knowledgeable guest. I've used this podcast as a research tool more than once. Before evaluating a new database or infrastructure tool, I search the SE Daily archive for an episode about it. Hearing the creator explain their design decisions in their own words is worth more than reading ten comparison blog posts. The transition to new hosts has been smooth. The interview style remains focused and technical without being academic. They ask the right follow-up questions and they're not afraid to push back when a guest makes a bold claim.

Best for: Developers who want broad exposure to different technologies. Engineers evaluating tools and platforms. Anyone who listens to a lot of podcasts and wants consistent daily content.

Where to listen: softwareengineeringdaily.com or any podcast app.

Pro tip: Don't try to listen to every episode. Use the show like a reference library. Browse titles, pick the ones relevant to your current work or interests, and skip the rest. Over time you'll naturally hear about dozens of technologies you wouldn't have encountered otherwise.

4. The Pragmatic Engineer

Host: Gergely Orosz

Episode length: 60 to 90 minutes. New episodes every two weeks.

What it covers: Engineering management, Big Tech culture, hiring practices, compensation, team dynamics, and the business side of software engineering.

Why it made the list: Gergely Orosz spent years as a senior engineer and engineering manager at Uber, and it shows. His podcast is the companion piece to his wildly popular newsletter, and together they've become the go-to resource for understanding how top tech companies actually operate. What makes this show special is that Gergely talks about the things most people in tech whisper about. Compensation bands. How promotion committees actually make decisions. Why some companies have great engineering culture and others just pretend to. He backs everything up with data and real examples from named companies, not vague "at a FAANG company I worked at" handwaving. The podcast format works because Gergely brings on guests who are engineering leaders at companies you've heard of, and he asks them the blunt questions everyone wants answered. "How much do your senior engineers make?" "Why did that reorganization fail?" "What actually happens in your hiring pipeline?" If you're an engineer who wants to understand the business context of your work, or if you're working toward a promotion, this is required listening.

Best for: Mid-career to senior engineers. Anyone interested in engineering management. Developers who want to understand compensation, hiring, and career growth at top companies.

Where to listen: newsletter.pragmaticengineer.com/podcast or any podcast app.

Pro tip: Pair the podcast with Gergely's newsletter. The newsletter often goes deeper on topics the podcast introduces. Together, they give you a more complete picture of the engineering industry than any other single source.

5. CoRecursive

Host: Adam Gordon Bell

Episode length: 45 to 60 minutes. Monthly episodes.

What it covers: The stories behind software. How projects started, why they failed, the human drama behind technical decisions, and the people who shaped the tools we use.

Why it made the list: CoRecursive is the most underrated developer podcast and I'll die on that hill. Adam Gordon Bell produces narrative-style episodes that read like mini-documentaries. His episode about the creation of SQLite is a masterpiece. The one about the development of Erlang at Ericsson is fascinating even if you've never written a line of Erlang. The one about the person who saved healthcare.gov from collapse will give you chills. What makes CoRecursive different from every other interview podcast is the production. Adam doesn't just sit someone down and ask questions for an hour. He researches the story beforehand, structures it with a narrative arc, and weaves in context and commentary. You're not listening to a conversation. You're listening to a story that happens to teach you something profound about software development. The downside is that episodes come out monthly, not weekly. But honestly, each episode is so dense with insight that monthly feels about right. You need time to process what you heard.

Best for: Any developer who likes great storytelling. People who want to understand the history and culture of software development. Engineers who are tired of "tips and tricks" content and want something deeper.

Where to listen: corecursive.com or any podcast app.

Pro tip: Start with the SQLite episode ("The Untold Story of SQLite"). It's the perfect introduction to the show's style and it'll change how you think about one of the most-used pieces of software on Earth.

6. Latent Space

Hosts: Swyx (Shawn Wang) and Alessio Fanelli

Episode length: 60 to 90 minutes. Weekly episodes.

What it covers: AI and machine learning from an engineering perspective. LLMs, agents, inference optimization, prompt engineering, and AI infrastructure.

Why it made the list: The AI podcast space is a dumpster fire of hype and misinformation. Latent Space is the exception. Swyx and Alessio are technical enough to ask real questions and experienced enough to know when a guest is overselling. They interview the people actually building AI systems at companies like OpenAI, Anthropic, and dozens of AI startups, and they dig into the engineering details that matter. When everyone else was saying "AI will replace all developers," Latent Space was doing episodes on the actual architecture of coding agents, what they can and can't do, and where the real bottlenecks are. That kind of grounded analysis is rare and incredibly valuable when you're trying to figure out how AI tools fit into your workflow. If you've been reading our guide on AI coding assistants, this podcast goes several layers deeper. Swyx also has a unique background, having been both a developer advocate and an active open-source contributor, which gives him the ability to bridge the gap between research papers and practical engineering.

Best for: Developers integrating AI into their products. Engineers evaluating AI tools and infrastructure. Anyone who wants to stay current on AI without drowning in hype.

Where to listen: latent.space/podcast or any podcast app.

Pro tip: Their recap episodes after major AI announcements (new model releases, conference keynotes) are gold. Instead of reading 50 hot takes on Twitter, listen to Swyx and Alessio break down what actually matters and what's marketing.

7. Developer Tea

Host: Jonathan Cutrell

Episode length: 10 to 20 minutes. Two to three episodes per week.

What it covers: The psychology of being a developer. Decision-making, cognitive biases, motivation, burnout, focus, and the mental models that make good engineers great.

Why it made the list: Developer Tea is unlike anything else on this list. Jonathan Cutrell doesn't teach you a programming language or review a framework. He teaches you how to think. His episodes on cognitive load, decision fatigue, and managing complexity have legitimately changed how I approach my work. The short format is brilliant because it means there's zero filler. Each episode delivers one idea in 15 minutes and then gets out of your way. You can listen to three episodes during a lunch break and walk away with three actionable insights about how you work. Jonathan's episode on "the two types of technical debt" reframed how I think about code quality tradeoffs. His episodes on imposter syndrome are more useful than most of the self-help books I've read. If you're dealing with imposter syndrome as a developer, start here. This podcast won't help you pass a coding interview. It'll help you become the kind of engineer who makes good decisions under pressure, communicates clearly, and doesn't burn out. Those skills matter more than any framework you'll ever learn.

Best for: Every developer, period. But especially those feeling overwhelmed, dealing with burnout, or wanting to level up their soft skills and decision-making.

Where to listen: developertea.com or any podcast app.

Pro tip: Listen to Developer Tea first thing in the morning instead of checking Slack or email. Starting your day with 15 minutes of intentional thinking about how you work is more valuable than 15 minutes of reacting to other people's priorities.

8. Software Engineering Radio

Host: Rotating hosts from the IEEE Software magazine team

Episode length: 50 to 70 minutes. Biweekly episodes. Running since 2006.

What it covers: Software architecture, distributed systems, security, testing, deployment strategies, and engineering principles that stand the test of time.

Why it made the list: Software Engineering Radio has been running for nearly 20 years. Let that sink in. This show predates the iPhone. It predates Docker, Kubernetes, React, and basically every tool you use today. And it's still relevant because it focuses on principles, not products. The hosts rotate, which keeps the perspectives fresh. The guests tend to be practitioners and researchers who've spent decades thinking about software engineering problems. You won't hear about the hot new JavaScript framework here. You'll hear about why certain architectural patterns fail at scale, how to design systems that are actually testable, and what the research says about developer productivity. Think of SE Radio as the "eat your vegetables" podcast. It's not flashy. The episodes won't go viral on Twitter. But the knowledge compounds. After a year of listening, you'll understand software engineering at a fundamentally deeper level than someone who only follows trend-focused shows. Their episode archive is a goldmine. Search for any concept (event sourcing, CQRS, observability, testing strategies) and you'll find an episode with an expert who wrote the book on it. Literally.

Best for: Senior developers and architects who want depth over trends. Anyone preparing for system design interviews. Engineers who value timeless principles over flavor-of-the-month tools.

Where to listen: se-radio.net or any podcast app.

Pro tip: The episode with Charity Majors on observability (Episode 548) is one of the best single podcast episodes in the software engineering space. It'll change how you think about monitoring and debugging production systems. Listen to it even if you think you already understand observability.

9. Soft Skills Engineering

Hosts: Dave Smith and Jamison Dance

Episode length: 25 to 35 minutes. Weekly episodes.

What it covers: The non-technical side of being a developer. Dealing with difficult managers, navigating office politics, salary negotiation, job searching, career pivots, and all the human problems that happen around the code.

Why it made the list: This is the podcast I recommend most often to developers who message me about career problems. Dave and Jamison answer real questions from real listeners, and their advice is consistently practical and honest. "My manager takes credit for my work. What do I do?" "I've been at the same company for 8 years. Should I leave?" "My coworker writes terrible code and nobody else seems to care." These are the problems that actually make developers miserable, and no amount of LeetCode practice will solve them. The show's format works because the questions come from the audience. You're not hearing hypothetical scenarios. You're hearing the exact messy situations real developers face. And Dave and Jamison bring different perspectives. Dave tends to give diplomatic, measured advice. Jamison is more direct and sometimes provocatively blunt. The tension between their styles produces better advice than either could give alone. It's also genuinely funny. They don't take themselves too seriously, which makes the sometimes heavy career advice feel more approachable. Learning to handle the human side of your career is one of the most important developer skills for 2026.

Best for: Developers at any career stage who struggle with the "people stuff." Anyone negotiating salary, dealing with a bad team situation, or considering a job change. Basically every developer, because we all have these problems.

Where to listen: softskills.audio or any podcast app.

Pro tip: When you're going through a specific career situation (salary negotiation, bad manager, job switch), search their back catalog. With hundreds of episodes, they've almost certainly answered a question similar to yours. It's like having career advisors on demand.

10. Hanselminutes

Host: Scott Hanselman

Episode length: 30 to 40 minutes. Weekly episodes. Running since 2006.

What it covers: Technology, culture, diversity in tech, accessibility, and the people behind the products. Broader in scope than most developer podcasts.

Why it made the list: Scott Hanselman is a veteran. He's been at Microsoft for years, was blogging about code before most current developers were born, and has a perspective that comes from seeing the industry evolve over decades. Hanselminutes isn't purely technical. Scott interviews developers, designers, community organizers, accessibility advocates, and people building technology for underserved communities. The result is a podcast that makes you think about the impact of code, not just the implementation. Some episodes will teach you a new technology. Others will make you reconsider who you're building for and who's being left out. That breadth is the show's strength. It prevents the tunnel vision that happens when you only consume pure tech content. Scott's interviewing style is warm but probing. He genuinely listens and asks follow-up questions that reveal insights the guest didn't plan to share. After 18 years and nearly a thousand episodes, he's one of the best interviewers in the developer podcast space.

Best for: Developers who want a broader perspective on technology and its impact. Anyone interested in accessibility, diversity, and building inclusive software. Engineers who feel like they're in a tech bubble and want to expand their worldview.

Where to listen: hanselminutes.com or any podcast app.

Pro tip: Scott's personal blog is a treasure trove too. His post "Scott Hanselman's Complete List of Productivity Tips" gets updated regularly and contains some of the best developer productivity advice you'll find anywhere. The podcast and blog complement each other perfectly.

11. Talk Python to Me

Host: Michael Kennedy

Episode length: 60 to 75 minutes. Weekly episodes. Over 480 episodes.

What it covers: Python. All of it. Web development, data science, machine learning, automation, testing, package management, community news, and the people building the Python ecosystem.

Why it made the list: If you write Python, this is your podcast. Period. Michael Kennedy has interviewed basically everyone who matters in the Python ecosystem. Core developers, library maintainers, educators, and people using Python in fields from astrophysics to finance. The technical depth is real but never exclusionary. Michael explains enough context that you can follow episodes about topics outside your specialty. I'm not a data scientist, but I've learned a ton about pandas and numpy internals from episodes targeted at that audience because Michael makes the conversations accessible. His weekly "Python Bytes" companion podcast (co-hosted with Brian Okken) is a shorter news-format show that covers the most interesting Python stories each week. Together, the two shows keep you completely current on everything happening in the Python world. Python remains one of the most popular languages for a reason, and if you're thinking about learning a new language, this podcast will show you the full scope of what's possible.

Best for: Python developers at any level. Data scientists and ML engineers. Anyone considering learning Python or expanding their Python skills beyond web development.

Where to listen: talkpython.fm or any podcast app.

Pro tip: Michael also runs paid Python courses at talkpython.fm/courses. The podcast episodes often introduce topics that the courses go deep on. Listen to the podcast first to see if a topic interests you, then consider the course if you want structured learning. It's a smart learning pipeline.

12. CodeNewbie

Host: Saron Yitbarek

Episode length: 45 to 60 minutes. Biweekly episodes.

What it covers: The human side of learning to code. Career changes, self-taught journeys, bootcamp experiences, first jobs, and the emotional reality of becoming a developer.

Why it made the list: I know what you're thinking. "I'm not a code newbie. Why would I listen to this?" Because CodeNewbie does something no other podcast does. It tells the stories of people in the middle of the struggle. Not the success stories told in hindsight by someone who's already made it. Real conversations with people who quit their jobs to learn to code, who failed their first technical interviews, who wondered if they made a terrible mistake. Saron Yitbarek is a gifted interviewer who creates a safe space for honest conversation. The vulnerability in these episodes is rare in tech media. And the stories are inspiring in a way that doesn't feel manufactured. You'll hear from a teacher who became a developer at 40. A single parent who learned to code during nap times. A former musician who now works at a startup. If you're already experienced, these stories remind you why getting into tech matters. They reconnect you with the excitement you felt when you wrote your first working program. That's a feeling worth revisiting. And if you're someone who's switching careers to software development or trying to land your first developer job, this podcast will show you that your path is completely valid, no matter how unconventional it looks.

Best for: Beginners and career changers. Experienced developers who want to remember why they love this field. Mentors looking for empathy and understanding of what new developers face. If you mentor junior developers, this is essential listening.

Where to listen: codenewbie.org/podcast or any podcast app.

Pro tip: Share specific CodeNewbie episodes with friends or family members who are considering learning to code. The stories are accessible to non-technical people and often provide the motivation someone needs to actually start. It's the best "I'm thinking about learning to code, where do I start?" resource that exists.

How to Build a Podcast Habit That Actually Sticks

Subscribing to 12 podcasts and listening to none of them isn't a learning strategy. Here's how I actually use podcasts to get smarter over time.

First, I pick three "must-listen" shows and everything else is optional. For me those are Syntax, The Changelog, and Developer Tea. I listen to every episode of those three. The rest I cherry-pick based on the topic. This prevents podcast overwhelm, which is a real thing. If you try to listen to everything, you'll listen to nothing.

Second, I listen at 1.5x speed for most shows. Some people swear by 2x. I find that too fast for technical content because I miss nuance. 1.5x hits the sweet spot of faster consumption without losing comprehension. Start at 1.25x if normal speed is too slow and work up from there.

Third, I keep a running note in my phone called "Podcast Takeaways." When an episode gives me an idea I want to act on, I pause and type one sentence about it. Just one. "Try the Bruno API client instead of Postman." "Look into event sourcing for the payments service." "Ask Sarah about the team structure thing Gergely described." These single-sentence notes compound. I review them every Friday and pick one or two to actually follow up on. That's the bridge between passive listening and active learning.

Fourth, commutes and chores are the best podcast time. I don't sit down and listen to podcasts. I listen while driving, doing dishes, walking the dog, or working out. This turns dead time into learning time without taking away from your coding practice or project work.

What I Left Off (And Why)

I didn't include shows that are primarily about specific companies' products. Some companies produce great podcast content, but if every episode is steering you toward their paid product, the advice has a conflict of interest baked in. I also left off shows that haven't posted a new episode in over 6 months. A podcast needs to be active to earn a recommendation. And I skipped pure news recap shows. Those have their place, but they don't teach you anything lasting. Next week's news will replace this week's, and you won't remember any of it. The shows on this list give you knowledge that lasts years, not hours.

The developer podcast ecosystem is huge and growing. These 12 shows are where I'd start if I was building my listening habit from scratch. Give each one two or three episodes before deciding if it's for you. Podcast chemistry takes a few episodes to appreciate, and the best shows get better the longer you listen.