Alle afleveringen
80 afleveringen, van nieuw naar oud
-
The revised rules of engineering management with Will Larson
21 oktober 2026 · 1 uur 56 min
Brought to You By: Lees meer
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.
• Entire – Git hosting, rebuilt for the agentic era. Every agent session, prompt and tool calls: stored in your repo.
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
—
What’s changed in “the unwritten rules” of engineering management since the 2010s, what drove the shift to today, and what has it done to the engineer-to-CTO career path? Today’s guest is one of the best people I know who can tackle these questions.
Will Larson is CTO of Imprint, was an engineering executive for 10+ years, and is the author of several popular books on engineering leadership, including ‘The Engineering Executive's Primer,’ ‘Staff Engineer, An Elegant Puzzle,’ and ‘Crafting Engineering Strategy.’ Previously, he was also CTO at Carta and Calm, and an engineering leader at Stripe and Uber.
In this episode, we explore how engineering leadership has evolved from management practices shaped in the long post-financial-crisis ZIRP era to the altered expectations of engineers and managers today.
Is middle management an increasingly precarious career path, and might managers need to reskill and return to hands-on technical work – or even consider retirement? Will makes the case, and we hear why the traditional path to engineering executive roles is changing, as well as why taking one step backward might sometimes be the best way forward.
We discuss Will's early career, and get his first-hand account of Digg's disastrous relaunch, his own path to CTO, and he tells us why career ladders still matter. We also explore how AI is changing engineering roles and bringing technical decision-making back to leadership.
Timestamps
00:00 Intro
08:20 Stories from Yahoo!
12:47 Digg’s v4 rewrite: the insider story
26:02 Will’s path to eng leadership
30:03 Uber, Stripe, Carta, a…
-
Uber’s AI infra, from the inside
14 oktober 2026 · 1 uur 33 min
Brought to You By: Lees meer
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable
• Linear – the product development system for teams and agents
• WorkOS – everything you need to make your app enterprise-ready.
—
What do developer tools look like inside of Uber, today? They are very different from what you would see at most places. For example, can you guess what service a system called DevPods, Code Inbox, Slate or Wisdom would be providing to engineers?
Today’s episode is a deepdive into the day-to-day tools of devs at Uber, our tour guide being on of Uber’s longest-tenured engineers: Uday Kiran Medisetty. Uday is one of the few Distinguished Engineers at the company, and leads much of the work on agentic AI, today.
With Uday, we talk through how Uber’s developer infrastructure prepared it for AI agents. We look at the systems Uber built before generative AI and the new tools that connect agents to its code, internal services, and engineering knowledge. Uday explains how engineers use background agents, why tools like Slate make development (and bugfixing!) more efficient, and how code review is changing. We also cover Uber’s approach to token costs and how it measures productivity as the engineer’s role changes.
Timestamps
00:00 Intro
02:48 Uday’s early days at Uber
05:40 Uber’s move to microservices
07:55 Uber’s engineering team, then and now
09:05 Developer tooling before AI
16:03 DevPods
19:28 Building for AI agents
29:27 MCP gateway
34:37 Agent Skills repo
38:46 The context graph and Cortana
47:54 PRD and ERD tool
50:45 Minion
54:46 Testing and code review with Bazel, Slate, and Capri
1:12:26 Edge Gateway, Shepherd, and Wisdom
1:21:33 The changing role of engineer and measuring productivity
1:30:40 Uday’s favorite new products
—
The Pragmatic Engineer deepdives relevant for this episode:
• How Uber uses AI for development: inside look
• Scaling Uber with Thuan Pham (Uber's fi…
-
Building resilient systems with Sam Newman
7 oktober 2026 · 1 uur 58 min
Brought to You By: Lees meer
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.
• Entire – Git hosting, rebuilt for the agentic era. Every agent session, prompt and tool calls: stored in your repo.
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
—
Sam Newman wrote one of the most-read books about microservices (“Building Microservices”), but he calls them an architecture of “last resort.”
In this episode of the Pragmatic Engineer podcast, Sam explains his thinking on this, and he’s certainly well placed to do so; he was in the room when the term “microservices” was coined. We discuss what teams get wrong when adopting microservices, why independent deployment matters, and how microservices can help teams work more autonomously.
We also delve into his new book, ‘Building Resilient Distributed Systems’, and Sam explains his three rules for distributed systems, why observability is essential, and also why it’s vital to take business context into account when deciding whether to fail open or fail closed on errors.
We also explore how AI is changing software development, from specs versus code as a source of truth to cognitive debt and cognitive surrender. Sam shares how modular architecture can help teams experiment with AI while maintaining understanding of the systems being built.
Timestamps
00:00 Intro
03:16 Sam’s path into tech
09:32 Thoughtworks
20:55 The rise of microservices
33:37 Are specs becoming more important than code?
45:22 Building Resilient Distributed Systems (Sam’s new book)
52:35 Three rules of distributed systems
56:16 Observability
1:02:20 Resilience tradeoffs
1:07:54 Idempotency
1:15:58 Thundering herds
1:21:03 Business context and resilience decisions
1:25:51 Resilience engineering: four concepts
1:32:42 AI and resilience
1:36:26 AI’s limitations and where to use it
1:40:06 Cognitiv…
-
Distributed databases with Peter Mattis
30 september 2026 · 1 uur 42 min
Brought to You By: Lees meer
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable
• Linear – the product development system for teams and agents
• WorkOS – everything you need to make your app enterprise ready.
—
How is it that a software veteran who regularly shipped ~100K of database-grade code to production each year, pre-AI, feels like he’s even more productive today, with no drop in quality? Peter Mattis is co-founder and CTO of Cockroach Labs, and an original creator of GIMP. He also worked on Gmail and distributed storage at Google.
In this episode, Peter reflects on his journey from open source to Google to founding a database company, and we explore how to keep systems fast, reliable, and correct at scale, from Gmail’s early storage challenges to the tradeoffs in building distributed databases.
Peter tells us how AI has brought him back to writing code after his work shifted toward management, and why he believes AI can improve quality and multiply the impact of domain experts. We also consider the future of code review, and Peter has some advice about how to level up our engineering skills.
Timestamps
00:00 Intro
02:42 Peter’s path into tech
04:00 Building GIMP
09:30 Working on Gmail at Google
14:51 Google’s infra: google3, build files, Bazel, and Colossus
21:30 Distributed storage bottlenecks
23:59 Latency, throughput, and availability
30:04 Contributing to libraries
41:52 Google Spanner
46:10 CockroachDB
52:00 Manual vs. automatic sharding
55:28 Consistency models and strong consistency
1:00:03 Raft consensus
1:06:15 How AI brought Peter back to coding
1:19:12 Peter’s tools and agentic workflows
1:23:08 How AI can improve quality
1:26:39 Code reviews: are they done?
1:29:17 100x engineers
1:35:33 Peter’s advice for leveling up your engineering skills
—
The Pragmatic Engineer deepdives relevant for this episode:
• Inside Google’s Engineering Culture
• Resiliency in dis…
-
Design Engineering with Maggie Appleton
23 september 2026 · 1 uur 27 min
Brought to You By: Lees meer
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.
• O'Reilly Early Release: Scaling AI Adoption in Engineering – a free book on how to adopt and scale AI in a pragmatic way inside of engineering orgs. Complimentary, thanks to Antithesis.
• Entire – every agent prompt, tool call, stored in your repo, and mirrored.
—
What can everyone else learn from designers and design engineers? As it turns out, there’s plenty, as I discovered when one of the best design engineers in the industry, Maggie Appleton, came onto the Pragmatic Engineer Podcast. She’s a staff research engineer at GitHub Next, where she builds prototypes to explore how software engineers might collaborate with AI in new ways. Maggie is at the intersection of design, anthropology, and web development, and was the first designer hired by AI startup Elicit, and Lead Design engineer at AI startup, Normally.
Today’s episode is more visual than usual because Maggie brought her notebook along, so there are peeks inside its pages of prototypes and more:
We got into designers’ work and how their design processes are adapting to and changing with AI. We explore why Maggie starts projects with pens and notebooks, what distinguishes design engineers from other designers, and why understanding engineering constraints leads to better collaboration with engineers.
We also discuss how Maggie uses jigs to gain more control over AI agents, why human judgment and style still matter when models can generate designs, and how inconsistent AI capabilities can mislead us.
Timestamps
00:00 Intro
03:24 From anthropology to tech
10:18 What does a designer do?
18:23 How Maggie works
24:55 The case for planning with physical tools
31:53 Why Maggie is learning woodworking
33:13 Design engineers and engineering constraints
38:49 How Maggie uses Figma
40:30 Design at GitHub Next
45:12 How has AI changed design
50:37 When models d…
-
AI Skills with Matt Pocock
17 september 2026 · 1 uur 36 min
Brought to You By: Lees meer
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable
• Linear – the product development system for teams and agents
• WorkOS – everything you need to make your app enterprise ready.
—
Why is the “grill-me” skill so popular, and why does its creator swear by the importance of software fundamentals? Matt Pocock created this widely-used skill – and many others – alongside being an educator, content creator, and engineer. His latest course is AI Hero, and he previously created the Total TypeScript course that generated more than $2.5 million in sales.
In this episode, Matt and I discuss his unconventional path from working as a voice teacher to becoming a developer and going all-in on technical education. He reveals how communication skills helped him break into tech, why he took an unusual three-days-a-week contract at Vercel, and how he built Total TypeScript through workshops, courses, and a lot of free content.
We also explore “strategic coding,” and how he uses skills like “grill me” and “wayfinder” to plan, delegate, and course-correct with AI agents. Matt explains his “day shift” and “night shift” approach, why splitting context up can keep agents in their “smart zone,” and how concepts from classic software engineering books can guide agents to do better. In this episode, there’s also local versus cloud workflows, whether agents need TDD, how AI is changing the ways that engineers learn the fundamentals, and why humans are still essential in teaching.
Timestamps
00:00 Intro
05:48 How Matt got into tech
10:14 How Matt got into open source
12:58 Joining Vercel
18:39 Total TypeScript
23:21 AI’s impact on technical education
30:32 Building reusable skills for AI coding agents
40:46 The “smart zone” vs the “dumb zone”
45:02 The wayfinder skill
47:52 Why agents excel at software engineering
50:54 “Leading words”
1:01:10 Learning the fundamentals
1:09:17 Local vs.…
-
Building Codex with Tibo Sottiaux
9 september 2026 · 1 uur 13 min
Brought to You By: Lees meer
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• Entire – Git hosting, rebuilt for the agentic era. Every agent session, prompt and tool calls: stored in your repo.
—
Tibo Sottiaux is one of the engineers who created Codex, and today, he heads up the Core Products & Platform org at OpenAI which also includes Codex. He’s also one of the most public faces of Codex due to his frequent – and generous – usage reset announcements, like this one yesterday.
In this episode of the Pragmatic Engineer Podcast, Tibo and I discuss how Codex was built and continues to be iterated upon. We explore why the Codex CLI is written in Rust and was released as open source, how the harness and models have evolved, and why Codex supports models from multiple providers.
Tibo also shares details about how the OpenAI team uses Codex throughout the software development lifecycle, including code reviews, maintenance, and system rearchitecture. We look into how AI is lowering the cost of changing code – and some interesting side effects of this – the merger of ChatGPT and Codex, and also how Tibo uses the tools in his own work.
—
Timestamps
00:00 Intro
07:21 Working at Google
12:41 What drew Tibo to OpenAI
15:19 The early days of Codex
18:20 Why Codex was built in Rust
21:15 Why Codex is open source
25:50 Codex plays nice with other models: why?
32:09 How the harness works
36:44 Harness and model improvements
41:19 The SDLC behind Codex
46:39 Code reviews at Codex
52:09 Maintenance and architecture
56:43 How AI tools expand what engineers can do
1:02:30 The Merge: ChatGPT + Codex
1:07:16 How Tibo uses Codex and ChatGPT
1:10:44 Advice for engineers who want to work in AI
—
The Pragmatic Engineer deepdives relevant for this episode:
• How Codex is bui…
-
Why performant code matters (but gets widely ignored), with Casey Muratori
26 augustus 2026 · 1 uur 53 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• Sentry – application monitoring software considered “not bad” by millions of developers.
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.
—
There can be few people around who care about software performance more than today’s pod guest, Casey Muratori. He’s a programmer and videogame developer, founder of Molly Rocket, and creator of Handmade Hero – a long-running series about building a game from scratch. He also evangelizes about performance on his Substack, Computer, Enhance.
We got to know each other about three years ago, first via messages, including this one from Casey:
“Why does the industry zeitgeist place so little emphasis on software performance when there seems to be overwhelming evidence that performance is critical to their bottom line?
Like you, I run a Substack for professional programmers, but I focus exclusively on software performance. Although we are quite large by Substack standards, so a certain subset of programmers must believe performance is important, I nonetheless hear lots of dismissive excuses when I post on social media. This happens so frequently, I devoted an entire article to cataloging the extensive pro-performance evidence we already have from the world's leading software companies: Performance Excuses Debunked.
Strangely, nobody has a rebuttal to why performance is important. When I point people to this, they actually tend to agree. But the prevailing attitude nonetheless stays the same.”
I’m delighted we finally have Casey on the podcast because it’s overdue! In this episode, we discuss why software performance matters, why it’s overlooked, and how developers can get better at writing performant code. We explore why performance should be considered during design, the value of learning to read assembl…
-
From Chrome DevTools to AI Engineering, with Addy Osmani
19 augustus 2026 · 1 uur 32 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• Google Cloud Run – run your code and host LLMs directly on top of Google’s scalable infrastructure, without having to worry about managing infra.
• Sentry – application monitoring software considered “not bad” by millions of developers
—
Addy Osmani spent more than 14 years at Google, working on Chrome, DevTools, Core Web Vitals, and most recently, AI developer experience.
If you've ever opened Chrome DevTools, or optimized a page for Core Web Vitals, you’ve used software built by Addy Osmani. In this episode, I sit down with Addy and we talk about his path from building a web browser aged just 16 to becoming a director at Google. We discuss what he learned from building tools for millions of developers, Google’s engineering culture, and why he continued doing hands-on coding work as a manager. We also get into how he works with AI agents today, the risks of ‘cognitive surrender,’ his approach to ‘loop engineering,’ and why it’s good to develop skills in product management, go-to-market, and other areas.
—
Timestamps
00:00 Intro
02:50 Addy’s current workflow
05:11 Addy’s path into tech
15:04 Addy’s work on jQuery
16:44 TodoMVC
21:44 Getting hired at Google and working on Chrome
27:17 Building dev tools
40:15 Core Web Vitals
45:42 Google’s engineering culture
51:03 Addy’s career trajectory at Google
57:55 The director role at Google
1:01:40 Cognitive debt and cognitive surrender
1:03:03 Working with agents
1:05:52 Loop engineering
1:12:55 The changing role of the software engineer
1:18:15 How Addy uses AI in writing
1:27:40 What’s next for Addy
1:28:47 Career advice
—
The Pragmatic Engineer deepdives relevant for this episode:
• What is loop engineering?
• Inside Google’s engineering culture
• How AI-assisted coding will change software engineering: hard truths
• Are AI agents actually…
-
Stop being skeptical about AI for development with Charity Majors
12 augustus 2026 · 1 uur 26 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• WorkOS – everything you need to make your app enterprise ready.
• Buildkite – CI software built to absorb whatever your coding agents throw at the build queue
—
In 2025, it was rational to be skeptical about AI, but in 2026 it’s clear that AI is changing all of the industry, and there’s less and less place for skepticism. This take is from one of my favorite voices in software reliability and observability: Charity Majors, CTO and cofounder of Honeycomb, co-author of Observability Engineering. (Note: the second edition of Observability Engineering is out, and it’s pretty much a full rewrite of the book, I recommend grabbing it if you’re building reliable systems)
In this episode, I sat down with Charity to discuss how her thinking on AI has evolved, why she believes it is becoming a foundational part of software engineering, and what that means for how teams build, review, and ship software.
We explore how AI is changing the economics of code generation, why reliability and verification are increasingly the bottlenecks, and why the rise of non-deterministic systems requires more engineering discipline. Charity shares her views on code reviews, observability, DevOps, leadership, and why both AI skeptics and enthusiasts are getting important things right.
—
Timestamps
00:00 Intro
02:56 How Parse led to Honeycomb
06:00 The limits of individual productivity metrics
09:08 How Charity’s perspective on AI has evolved
13:50 Rewriting code vs. editing code
19:20 Production as a stage of development
22:14 Code reviews
26:56 Non-deterministic systems
31:11 Sensible uses of AI
37:41 The two AI camps
44:40 Why AI works so well for building software
49:42 DevOps
55:13 Modern observability
1:00:40 Handling context overload
1:01:56 What’s new in Observability Engineering’s 2nd edition
1:07:45 What effective…
-
Formal methods with Hillel Wayne
29 juli 2026 · 1 uur 24 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.
• WorkOS – everything you need to make your app enterprise ready.
—
There’s a popular theory that AI will finally make formal verification mainstream because mathematical proof of correctness will be needed when machines write most or all of the code. But will this happen? Today, I’m talking with one of the best people to tackle the prediction. Hillel Wayne is a formal methods consultant, educator, and author, who’s deeply interested in software history.
In this episode of Pragmatic Engineer podcast, I sit down with Hillel to compare software engineering with traditional engineering, discuss where formal methods fit into modern software development, and we explore why they are essential for some of the world's most complex systems. We cover the formal specification language, TLA+, walk through several formal verification tools, examine why distributed systems are so difficult to reason about, and look into whether AI will make formal methods accessible to more engineering teams.
—
Timestamps
00:00 Intro
03:21 The Crossover Project
10:26 What software engineering does better
14:19 What traditional engineering does better
17:06 Formal methods
28:21 TLA+: what it is and demo
35:47 TLA+ at Amazon
36:59 Ways distributed systems break
39:52 Formal methods and systems thinking
45:09 The value of learning math
49:12 What TLA+ is good for and isn’t
51:39 Alloy: a declarative language for software modeling
57:42 Other formal methods tools
1:00:13 Property-based testing
1:04:20 AI and the need for formal verification
1:11:18 Logic for programmers
1:13:24 Hillel’s 2025 prediction on AI’s impact
1:20:19 Book recommendation
—
The Pragmatic Engineer deepdives relevant for this episode:
…
-
Context engineering with Dex Horthy
15 juli 2026 · 1 uur 32 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• Buildkite – CI software built to absorb whatever your coding agents throw at the build queue.
• Sentry – application monitoring software considered “not bad” by millions of developers.
—
Knowing how LLM contexts work and how to work around context limitations – aka “context engineering” – is becoming more important for software engineers working with LLMs. Let’s look into what works and what doesn’t, today.
In this episode of The Pragmatic Engineer podcast, I sit down with the CEO and cofounder of HumanLayer, Dex Horthy, who coined the term “context engineering”. We discuss the ideas behind this context engineering, harness engineering, loop engineering, software factories, why his approach to AI-assisted software development has evolved, and how HumanLayer is helping engineering teams automate more of the software development lifecycle without sacrificing code quality.
—
Timestamps
00:00 Intro
03:35 Dex’s path into tech
05:36 Early work in platform engineering
07:30 Replicated
13:26 Metalytics
14:38 12-factor agents
20:29 Context engineering
25:40 Harness engineering
28:13 Context overload
32:47 Loop engineering
46:36 Software factories before and after AI
52:35 Automation limits
57:20 Three options for automating
1:01:02 RPI framework
1:06:18 Intentional compaction
1:13:50 Token harder vs. token smarter
1:18:46 AI slop
1:21:17 HumanLayer
1:31:11 Book recommendation
—
The Pragmatic Engineer deepdives relevant for this episode:
• How Uber uses AI for development: inside look
• Are AI agents actually slowing us down?
• AI Tooling for Software Engineers in 2026
• Vibe Coding as a software engineer
• How Claude Code is built
• AI Engineering in the real world
• The AI Engineering Stack
• How AI-assisted coding will change software engineering: hard truths
• The creator of OpenClaw:…
-
The Pragmatic Engineer AMA
8 juli 2026 · 1 uur 18 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
—
In this special “ask me anything” episode of Pragmatic Engineer podcast, I am in the hot seat facing questions sent in by subscribers that are read out by guest Volodymyr Giginiak, CTO and cofounder of Wordsmith AI, a legal tech startup (note: I’m an investor).
I tackle your questions on the software industry, AI, hiring, engineering organizations, career growth, the business model of the Pragmatic Engineer, and more. We also discuss where software engineering is headed, and I offer advice on some specific situations. Thanks to everyone who sent questions!
—
Timestamps
00:00 Intro
01:56 From Uber to writing
09:22 AI-native SDLC
14:00 AI and hiring
19:06 Engineers currently thriving
22:18 Junior roles
24:44 Meta’s war mode
27:54 AI at Big Tech vs. startups
36:46 Tech debt
41:36 Types of engineering managers
44:40 Measuring AI productivity
48:30 The value of CS degrees
50:53 AI at Pragmatic Engineer
56:09 Future-proofing your career
1:01:36 The EU job market
1:03:55 Making money as a creator
1:08:20 What’s next for The Pragmatic Engineer
1:09:27 Bunq and Pollen
1:13:38 Spotting trends
1:14:33 Book updates
1:15:20 Favorite books & tech products
1:17:13 What won’t change in engineering
—
The Pragmatic Engineer deepdives relevant for this episode:
• State of the software engineering job market in 2026
• The impact of AI on software engineers in 2026: key trends.
• How 10 tech companies choose the next generation of dev tools
• The reality of tech interviews
—
Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email podcast@pragmaticengineer.com.
Get full access to The Pragmatic Engineer at newsletter.pragmaticengineer.com/subscribe
-
How Kent Beck shapes the software engineering industry
1 juli 2026 · 2 uur 27 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.
• WorkOS – everything you need to make your app enterprise ready.
—
Few have made as big an impact on software engineering as this week’s guest on the Pragmatic Engineer podcast, Kent Beck. He created Extreme Programming, pioneered test-driven development (TDD), co-created JUnit, and is one of the authors of the famous ‘Agile Manifesto’. But these days, he's re-examining many ideas for the age of AI, and says we’re failing to accumulate trust during this new era at the same high rate as new code is being accumulated.
In this episode of the Pragmatic Engineer podcast, Kent and I dig into his journey from discovering Smalltalk in the early days of personal computing, to helping define modern software engineering practices. We explore the origins of TDD, design patterns, Extreme Programming, and Agile – along with some lessons learned at Apple and Facebook.
Kent explains why he believes software engineering is about far more than writing code, why no one yet knows exactly how engineers should work alongside AI agents, and how his "explore, expand, extract" framework can help engineers navigate major technology shifts.
—
Timestamps
00:00 Intro
03:47 Human engineers aren’t going away
08:00 Kent's path into tech
13:50 Undergraduate and graduate studies
17:21 Kent’s first programming job
18:54 The rise and fall of Smalltalk
27:04 Working with Ward Cunningham
37:36 Design patterns
44:05 Working at Apple
51:08 CRC Cards
59:29 Testing tools in the language
1:04:22 The C3 project with Martin Fowler
1:09:54 Extreme Programming
1:16:25 Developing TDD
1:25:07 Writing the Agile Manifesto
1:30:00 Agile’s impact
1:32:40 Agile’s downside
1:37:32 The Dotcom Bust
1:44:30 Lessons from working …
-
Tech interviews with NeetCode
24 juni 2026 · 1 uur 29 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• Sentry – application monitoring software considered “not bad” by millions of developers
• Google Cloud Run – run your code and host LLMs directly on top of Google’s scalable infrastructure, without having to worry about managing infra.
—
Navdeep Singh – oftentimes better known as NeetCode – is the creator of NeetCode.io, one of the most popular coding interview preparation platforms and YouTube channels for software engineers. Before building NeetCode full-time, he worked as a software engineer at Amazon and Google.
In this episode of The Pragmatic Engineer, I sit down with Neet to discuss his path from Amazon and Google to building his own startup, why he left Amazon after just two months, what he learned at Google, and the decision to leave a stable engineering career to bet on himself. We also discuss what coding interview preparation teaches beyond passing interviews, the value of going deep on difficult problems, and why systems thinking and domain expertise remain essential engineering skills in the age of AI.
Throughout the conversation, NeetCode makes the case that learning hard things is one of the single best investments an engineer can make, helping build the judgment and expertise that remain valuable no matter how the tools change.
—
Timestamps
00:00 Intro
02:57 Neet’s take on coding interviews
06:41 Getting into tech
08:56 Why Neet isn't a fan of the CAP theorem
13:12 Quitting Amazon after two months
18:22 Google vs Amazon
22:26 The origins of NeetCode
25:27 Leaving Google to go all in on NeetCode
32:02 Why Neet doesn't fix every bug
39:26 The value of coding interview prep
42:57 Systems thinking and domain expertise
47:28 Hiring at Big Tech
52:15 Tech stack at Neetcode
57:57 The NeetCode redesign contest
1:01:46 The future of software engineers
1:09:04 Hot takes: AGI, AI skill…
-
CI/CD with Robert Erez
17 juni 2026 · 1 uur 15 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• WorkOS – everything you need to make your app enterprise ready.
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.
—
Robert Erez is a principal engineer at Octopus Deploy, and a longtime expert in CI/CD, deployment systems, and software delivery. Rob and I were also once colleagues on the Skype web team, working on large-scale deployments and release processes.
In this episode of The Pragmatic Engineer, I sit down with Rob to discuss how teams deploy software safely and efficiently at scale. We cover Kubernetes, GitOps, platform engineering, progressive delivery, feature flags, cloud development environments, and the growing role of AI in CI/CD workflows. We also get into the tradeoffs in different deployment approaches, why self-hosted software still matters for some organizations, and the recent evolution of software delivery practices.
—
Timestamps
00:00 Intro
02:09 Canary deployments at Skype
05:01 Joining at Octopus Deploy
06:15 Continuous deployment
10:26 Why Kubernetes won
15:51 Kubernetes on-prem
18:50 How GitOps works
25:00 The uses and limitations of GitOps
31:04 The rise of platform teams
35:51 How AI is changing CI/CD
39:49 Progressive delivery explained
47:31 Rollbacks and roll-forwards
50:14 Feature flags
54:32 How development environments are evolving
57:40 Cloud development environments (CDEs)
1:03:45 Self-hosting CI/CD
1:09:25 Getting started with progressive delivery
1:11:15 Book recommendations
—
The Pragmatic Engineer deepdives relevant for this episode:
• Kubernetes and retiring at the top with Kelsey Hightower
• The past and future of modern backend practices
• Microsoft is dogfooding AI dev tools’ future
• How Kubernetes is built with Kat Cosgrove
• How Linux is built with Greg KH
—
Producti…
-
Kubernetes and retiring at the top with Kelsey Hightower
3 juni 2026 · 2 uur 51 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• Buildkite – CI software built to absorb whatever your coding agents throw at the build queue
• Sentry – application monitoring software considered “not bad” by millions of developers
—
Kelsey Hightower went from a self-taught technician installing DSL modems to becoming one of Google’s elite Distinguished Engineers, whom the CEO of Microsoft personally tried to recruit. Hightower’s career achievements are rooted in hard work and self-directed learning, and today he’s one of the most influential voices in modern infrastructure, through his talks, open source work, and writing.
In this episode of The Pragmatic Engineer podcast, Kelsey and I cover his unconventional path into tech and the lessons he’s learned during three decades in the industry. We discuss his entrepreneurial years, building a reputation through open source, the rise of containers and Kubernetes, and his time at Google during one of the most consequential periods in cloud computing.
He recounts how a job offer from a big tech giant led to the biggest raise of his career, what prompted him to slow down after years of career acceleration, and we also discuss his perspective on AI. Throughout, Kelsey keeps a simple idea front of mind: that technology is ultimately about people. Whether it’s infrastructure, leadership, careers, or AI, he argues that the goal is not to build technology for its own sake; it’s to solve meaningful human problems.
—
Timestamps
00:00 Intro
03:34 Kelsey’s first job at McDonald’s
05:04 His non-traditional path into tech
11:45 Landing his first tech job with an A+ certification
15:33 His entrepreneurial years
19:45 Joining Google as a data center technician
27:48 Learning automation at a Rackspace spinoff
33:26 Moving into financial services
50:00 Building a reputation through open source
53:55 From configuratio…
-
Building OpenCode with Dax Raad
27 mei 2026 · 1 uur 20 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• WorkOS – Everything you need to make your app enterprise ready.
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.
—
OpenCode is one of the fastest-growing AI developer tools around, surging in just a few months from roughly 650,000 monthly active users to nearly 8 million, and almost 1M daily active users.
In this episode of The Pragmatic Engineer Podcast, we meet Dax Raad, co-founder of OpenCode, for a discussion about the gaps in developer tooling that led him to build OpenCode, the advantages of open source, and why taste and engineering judgment matter even more as AI becomes a core part of software development.
We also cover how OpenCode turned Anthropic’s blocking of integration with Claude Code into a massive growth lever by partnering with OpenAI and other model providers, why GPU demand is becoming a bottleneck everywhere, how come AI coding tools don’t automatically mean engineering teams move faster, and also why Dax is personally skeptical about predictions for the future of engineering and work, in general.
I found this conversation especially interesting because Dax displays a healthy skepticism toward the benefits of AI, even while building one of the most popular AI coding harnesses.
—
Timestamps
00:00 Intro
07:03 Dax’s path into tech
09:04 Early startup experience
13:16 Getting involved with open source
16:13 OpenCode
23:17 Anthropic banning OpenCode
30:34 From terminal to GUI
32:34 OpenCode’s business model
36:33 Why inference is profitable
39:11 GPU bottlenecks
40:54 AI hype
45:50 AI spending
48:47 Dax’s memo
55:41 Dax’s skepticism of predictions
58:58 Engineering culture at OpenCode
1:02:38 How building works at OpenCode
1:05:36 Taste and quality
1:11:32 Dax’s work setup
1:12:35 The role of engineer…
-
Why Rust is different, with Alice Ryhl
20 mei 2026 · 1 uur 5 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• Sentry – application monitoring software considered “not bad” by millions of developers
• Craft Conference: join Gergely, Kent Beck, Hillel Wayne and others at the conference dedicated to the art and science of software delivery craft.
—
Rust is one of the most admired programming languages around – and also one of the hardest to learn. What makes developers stick with it?
In this episode of The Pragmatic Engineer Podcast, I sit down with Alice Ryhl, a software engineer on Google’s Android Rust team, and a core maintainer of Tokio, which is the most widely-used async runtime in Rust.
We discuss what makes Rust different from other languages like TypeScript, Go, and C++, and why so many developers say that “once it compiles, it works.” We go deep into memory safety, ownership, borrowing, unsafe Rust, and Cargo.
We also cover how Rust is governed by RFCs, feature flags, its six-week release cycle, how engineers get paid to work on the language, and also look into how Rust’s use inside the Linux kernel is progressing.
—
Timestamps
(00:00) Intro
(04:09) Tokio: an overview
(05:11) What Alice likes about Rust
(12:48) Rust for TypeScript engineers
(13:51) Moving from C++ to Rust
(14:34) Memory safety
(18:12) Garbage collection tradeoffs
(21:46) Ownership, references, and borrowing
(26:59) Unsafe in Rust
(31:21) Crates and Cargo
(35:55) Language design and RFCs
(43:02) Building new features
(46:30) Editions vs. versions
(49:47) Getting paid to work on Rust
(51:27) Contributing to Rust
(53:03) Rust in the Linux kernel
(55:45) AI use cases for Rust
(1:01:35) Learning Rust
(1:03:54) Book recommendation
—
The Pragmatic Engineer deepdives relevant for this episode:
• The past and future of modern backend practices
• How Kotlin was built with Andrey Breslav
• How Swift was built with Chris Lat…
-
TypeScript, C# and Turbo Pascal with Anders Hejlsberg
13 mei 2026 · 1 uur 15 min
Brought to You By: Lees meer
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• WorkOS – Everything you need to make your app enterprise ready.
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.
—
Anders Hejlsberg is a living legend and one of the most influential programming language designers of all time. He created Turbo Pascal, Delphi, C#, and also TypeScript. As well as that, he spent nearly a decade at the pioneering dev tools company, Borland, and is now in his 30th year of working at Microsoft, where he’s a Technical Fellow.
In this episode, we discuss what it takes to build programming languages that developers love to use, and trace his career from writing his first compiler to creating Turbo Pascal and Delphi, and helping to pioneer modern software development through C# and TypeScript.
Anders details how C# was designed by a small group of experienced language designers who met a few hours each week, and he explains why tooling was just as important as the language for TypeScript’s success, and what he has learned from building languages which stay relevant for decades.
We also look into how Anders uses AI today, which language features suit AI-assisted development, and what he thinks is changing in the craft of software engineering as developers move further away from writing code line by line.
—
Timestamps
(00:00) Intro
(02:48) How Anders got into programming
(05:40) Building his first compiler
(07:44) Turbo Pascal
(12:25) Delphi
(14:53) Joining Microsoft
(19:41) Building C#
(29:11) Async/await
(34:01) The rise of JavaScript
(37:52) Building TypeScript
(42:58) How the TypeScript compiler works
(48:30) JavaScript’s strengths and weaknesses
(52:18) How Anders uses AI
(56:03) What language features work well with AI
(1:02:49) How software craftsmanship is changing
(1:07:49) Performance and …
-
Building Pi, and what makes self-modifying software so fascinating
29 april 2026 · 1 uur 33 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
Mario Zechner is the creator of Pi, a minimalist, self-modifying AI coding agent, that is the foundation upon which OpenClaw (created by Peter Steinberger) is built. Meanwhile, Armin Ronacher is the creator of Flask, and a longtime user of Pi. The pair are also friends.
I sat down with Mario and Armin for the latest episode of the Pragmatic Engineer Podcast for an interesting conversation about AI and their reservations about it – even though both are heavily invested in building AI-powered tools.
Mario explains why he built Pi, and gives his take on why it has become so popular. Armin walks us through how he uses AI tools, including building a game with Pi, and why he always puts human judgment firmly at the heart of his approach.
We cover the risks of over-automation, the limits of agentic workflows, and why strong engineers with informed judgment still matter. We also get into the challenges of working with code written by non-engineers, and whether open source can withstand a tidal wave of agent-generated code.
—
Timestamps
(00:00) Intro
(07:30) How Mario, Armin, and Peter Steinberger met(15:15) How 30 dev teams use AI agents: learnings
(21:50) The importance of judgment
(24:26) Challenges when non-engineers write code
(28:30) Downsides of over-automation
(32:18) Pi
(48:09) OpenClaw + Pi
(50:54) “Clankers”
(57:32) Open source and AI
(1:00:22) Complexity as the enemy
(1:02:50) Building an AI-native startup
(1:11:52) “Slow the F down”
(1:16:40) MCPs vs. CLI
(1:25:03) Predictions and staying up to date
—
The Pragmatic Engineer deepdives relevant for this episode:
• The impact of AI on software engineers in 2026: key trends
• Cycles of disruption in the tech industry
• The AI engineering sta…
-
Designing Data-intensive Applications with Martin Kleppmann
22 april 2026 · 1 uur 25 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
Martin Kleppmann is a researcher and the author of Designing Data-Intensive Applications, one of the most influential books on modern distributed systems. As of this month, the second, heavily updated edition of the book is out.
In this episode of Pragmatic Engineer, we discuss Martin’s career in tech building startups, how he ended up writing this iconic book, and what he’s focused on now after moving into academia.
We talk about the tradeoffs behind modern infrastructure, how the cloud has changed what it means to scale, and the thinking behind Designing Data-Intensive Applications, including what’s changing in the second edition.
Martin reflects on lessons from building startups like Rapportive, which he sold to LinkedIn, and shares how his experience in both academia and industry shaped his perspective.
We also explore what’s ahead: why formal verification may become more important in an AI-assisted world, the challenges of building local-first software, and his recent research into using cryptography to improve transparency in supply chains without exposing sensitive data.
—
Timestamps
(00:00) Early career
(05:46) Building Rapportive
(10:47) Working at LinkedIn
(14:09) Writing Designing Data-Intensive Applications
(23:00) Reliability, scalability, and repeatability
(26:24) DDIA: the second edition
(30:50) Tradeoffs of using cloud services
(39:02) How the cloud changed scaling
(42:53) The trouble with distributed systems
(49:02) Ethics for software engineers
(52:45) Formal verification
(1:00:12) Academia vs. industry
(1:03:50) Local-first software
(1:09:50) Computer science education
(1:18:32) Martin’s current research and advice
—
The Pragmatic Engineer deepdives relevant for this episod…
-
DHH’s new way of writing code
8 april 2026 · 1 uur 46 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
David Heinemeier Hansson (DHH) is the creator of Ruby on Rails and Omarchy, co-founder and CTO of 37signals (maker of Basecamp and HEY), and the author of several books including the best-seller, Remote: Office Not Required, co-written with Jason Fried.
Six months ago, in an episode of the Lex Fridman podcast, David shared how he doesn’t use AI tools to write code: he types out all his code. But things have changed a lot since then.
In this episode, we discuss his approach to building software, how it’s changed in the last six months, and why he now takes an agent-first approach, and how he barely writes any code by hand. We go into how he uses AI agents: which alter how he builds and explores ideas, but also how his standards of quality and craft remain the same.
We also discuss how 37signals thinks about product development, from the role of designers to the importance of aesthetics and taste. David gets into how he sees beauty and functionality as closely linked, and why strong opinions about design lead to better software.
Finally, we look into the uneven impact of AI which amplifies senior engineers while creating challenges for junior developers, and what this may mean for the role of the software engineer.
—
Timestamps
(00:00) Intro
(02:11) Omarchy and Ruby on Rails
(08:25) 37signals overview
(10:12) Launching HEY
(18:38) Building HEY
(22:47) Designers at 37signals
(28:08) The craft of design
(31:52) Why DHH now embraces AI workflows
(39:45) The AI inflection point
(44:23) DHH’s agent-first workflow
(55:09) AI’s impact on junior developers
(1:03:08) Developer experience with AI
(1:16:43) What does AI mean for developers?
(1:23:33) 37signals teams and hiring
(1:38:20) Work-life balance wi…
-
Scaling Uber with Thuan Pham (Uber’s first CTO)
1 april 2026 · 1 uur 39 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
Thuan Pham was Uber's first and longest-serving CTO, and today he’s the CTO of Faire, a B2B wholesale platform. Back when Thuan joined Uber, it had around 40 engineers and 30,000 rides per day, and the system crashed multiple times a week. Over seven years, he helped rebuild the system, move it from a monolith to microservices, and scaled the engineering organization behind it. I had the privilege of working with Thuan for four of those seven years. Later, the very first issue of The Pragmatic Engineer newsletter was a deepdive into Uber’s Program and Platform split. This episode of the podcast contains a nice “full circle” moment, where Thuan shares even more details about why Uber chose to embrace that structure.
We discuss what it takes to operate and build in that kind of environment. Thuan explains how he divided his time at Uber into three “tours of duty,” from stabilizing a fragile system, to re-architecting it, and scaling the org.
We go deep into the platform-and-program split, the Helix app rewrite, and what it took to launch Uber in China in just five months (the original estimate was 18 months). We also cover Uber’s in-house tools and explain why they were necessary to support rapid growth.
Finally, we discuss his role today as CTO of Faire, how the company is using AI, and how he sees AI changing software engineering.
—
Timestamps
(00:00) Intro
(05:32) Getting into tech
(16:09) The dot-com bust
(20:42) VMware
(26:29) Getting hired by Travis at Uber
(33:22) Early days at Uber and scaling challenges
(40:57) Uber’s China launch
(47:12) The platform and program split
(50:26) From monolith to microservices
(53:38) Internal tools at Uber
(57:05) Helix: Uber’s mobile app rewrite
(59:55) Thuan…
-
Building WhatsApp with Jean Lee
18 maart 2026 · 1 uur 11 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
How did a tiny team of 30 engineers build the world-famous messaging app more than a decade ago, and what can dev teams learn from that feat today? Jean Lee was engineer #19 at WhatsApp, joining when the company was still small, with almost no formal processes. She helped it scale to hundreds of millions of users, went through the $19B acquisition by Facebook, and later worked at Meta.
In this episode of Pragmatic Engineer, I talk with Jean about what it was like building WhatsApp. When Facebook bought WhatsApp in 2014, only around 30 engineers supported hundreds of millions of users across eight platforms.
We discuss how the founders kept things simple, saying “no” to most feature requests for years. Jean explains why WhatsApp chose Erlang for the backend, why the team avoided cross-platform abstractions, and how charging users $1 per year paid everyone’s salaries, while keeping growth intentionally slow.
Jean also shares what the Facebook acquisition was like on the inside, how she dealt with sudden personal wealth, and what it was like transitioning from an IC to a manager at Facebook – including the reality of calibration meetings and performance reviews.
We also discuss how AI enables smaller engineering teams, and why WhatsApp’s experience suggests ownership and trust might matter more than tools.
—
Timestamps
(00:00) Intro
(01:39) Early years in tech
(06:18) Becoming engineer #19 at WhatsApp
(13:53) WhatsApp’s tech stack
(18:09) WhatsApp’s unique ways of working
(25:27) Countdown displays and outages
(27:07) Why WhatsApp won
(28:53) The Facebook acquisition
(33:13) Life after acquisition
(39:27) Working at Facebook in London
(44:07) Transitioning to management
(47:27) Performance reviews as…
-
From IDEs to AI Agents with Steve Yegge
11 maart 2026 · 1 uur 31 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
Steve Yegge has spent decades writing software and thinking about how the craft evolves. From his early years at Amazon and Google, to his influential blog posts, he has often been early at spotting shifts in how software gets built.
In this episode of Pragmatic Engineer, I talk with Steve about how AI is changing engineering work, why he believes coding by hand may gradually disappear, and what developers should focus on, instead. We discuss his latest book, Vibe Coding, and the open-source AI agent orchestrator he built called Gas Town, which he said most devs should avoid using.
Steve shares his framework for levels of AI adoption by engineers, ranging from avoiding AI tools entirely, to running multiple agents in parallel. We discuss why he believes the knowledge that engineers need to know keeps changing, and why understanding how systems evolve may matter more than mastering any particular tool.
We also explore broader implications. Steve argues that AI’s role is not primarily to replace engineers, but to amplify them. At the same time, he warns that the pace of change will create new kinds of technical debt, new productivity pressures, and fresh challenges for how teams operate.
—
Timestamps
(00:00) Intro
(01:43) Steve’s latest projects
(02:27) Important blog posts
(04:48) Shifts in what engineers need to know
(10:46) Steve’s current AI stance
(13:23) Steve’s book Vibe Coding
(18:25) Layoffs and disruption in tech
(31:13) Gas Town
(40:10) New ways of working
(51:08) The problem of too many people
(54:45) Why AI results lag in business
(59:57) Gamification and product stickiness
(1:04:54) The ‘Bitter Lesson’ explained
(1:07:14) The future of software development
(1:23:06) Where languages s…
-
Building Claude Code with Boris Cherny
4 maart 2026 · 1 uur 37 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
Boris Cherny is the creator and Head of Claude Code at Anthropic. He previously spent five years at Meta as a Principal Engineer and is the author of the book Programming TypeScript.
In this episode of Pragmatic Engineer, we went through how Claude Code was built and what it means when engineers no longer write most of the code themselves.
We discuss how Claude Code evolved from a side project into a core internal tool at Anthropic and how Boris uses it day-to-day. We go deep into workflow details, including parallel agents, PR structure, deterministic review patterns, and how the system retrieves context from large codebases. We also get into how Claude Cowork was built.
As coding becomes more accessible, the role of engineers shifts rather than shrinks. We examine what that shift means in practice, which skills become more important, and why the lines between product, engineering, and design are blurring.
—
Timestamps
(00:00) Intro
(11:15) Lessons from Meta
(19:46) Joining Anthropic
(23:08) The origins of Claude Code
(32:55) Boris's Claude Code workflow
(36:27) Parallel agents
(40:25) Code reviews
(47:18) Claude Code's architecture
(52:38) Permissions and sandboxing
(55:05) Engineering culture at Anthropic
(1:05:15) Claude Cowork
(1:12:48) Observability and privacy
(1:14:45) Agent swarms
(1:21:16) LLMs and the printing press analogy
(1:30:16) Standout engineer archetypes
(1:32:12) What skills still matter for engineers
(1:35:24) Book recommendations
—
The Pragmatic Engineer deepdives relevant for this episode:
• How Claude Code is built
• How Anthropic built Artifacts
• How Codex is built
• Real-world engineering challenges: building Cursor
—
Production and marketing by https…
-
Mitchell Hashimoto’s new way of writing code
25 februari 2026 · 1 uur 58 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
How has the day-to-day workflow of Mitchell Hashimoto changed, thanks to AI tools?
Mitchell Hashimoto is one of the most influential infrastructure engineers of our time, and is one of the most pragmatic builders I’ve met. He is the co-founder of HashiCorp and creator of Ghostty. In this episode, we talk about how he got into software engineering, the history of HashiCorp, and the challenges of turning widely used open-source tools into a durable business. We also go into what it’s really like to work with AWS, Azure and GCP as a startup.
Mitchell shares how he uses AI these days, and how agents have completely changed how he works. We touch on Ghostty, open source, and what’s changing for software engineers and founders in an AI-native era.
—
Timestamps
(00:00) Intro
(02:03) Mitchell’s path into software engineering
(07:19) The origins of HashiCorp
(15:52) Early cloud computing
(18:22) The 2010s startup scene in SF
(23:11) Funding HashiCorp
(25:23) The Hashi stack
(32:33) Why HashiCorp’s business lagged behind its technology
(35:28) An early failure in commercialization
(38:28) The open-core pivot and path to enterprise profitability
(48:08) Taking HashiCorp public
(51:58) The near VMware acquisition
(59:10) Mitchell’s take on all the cloud providers
(1:06:02) AI’s impact on open source
(1:07:00) Why Mitchell built Ghostty
(1:09:11) Why Mitchell used Zig
(1:10:38) How terminals work and Ghostty’s approach
(1:17:31) AI’s impact on terminals and libghostty
(1:19:13) How Mitchell uses AI
(1:22:02) Ghostty’s evolving AI use policy
(1:28:36) Why open source must change
(1:31:46) The problem of Git in monorepos
(1:36:22) What needs to change to work effectively with AI
(1:39:57) Mitchell’s hi…
-
The programming language after Kotlin – with the creator of Kotlin
12 februari 2026 · 1 uur 44 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
Andrey Breslav is the creator of Kotlin and the founder of CodeSpeak, a new programming language that aims to reduce boilerplate by replacing trivial code with concise, plain-English descriptions. He led Kotlin’s design at JetBrains through its early releases, shaping both the language and its compiler as Kotlin grew into a core part of the Android ecosystem.
In this episode, we talk about what it takes to design and evolve a programming language in production. We discuss the influences behind Kotlin, the tradeoffs that shaped it, and why interoperability with Java became so central to its success.
Andrey also explains why he is building CodeSpeak as a response to growing code complexity in an era of LLM agents, and why he believes keeping humans in control of the software development lifecycle will matter even more as AI becomes more capable.
—
Timestamps
(00:00) Intro
(01:02) Why Kotlin was created
(06:26) Dynamic vs. static languages
(09:27) Andrey joins the Kotlin project
(14:26) Designing a new language
(19:40) Frontend vs. Backend in language design
(21:05) Why is it named Kotlin?
(24:37) Kotlin vs. Java tradeoffs
(28:32) Null safety
(31:24) Kotlin’s influences
(39:12) Smartcasts
(40:42) Features Kotlin left out
(44:54) Bidirectional Java interoperability
(55:01) The Kotlin timeline
(58:00) Kotlin’s development process
(1:07:20) From Java to Android developers
(1:12:12) How Android became Kotlin-first
(1:18:20) CodeSpeak: a language for LLMs
(1:24:07) LLMs and new languages
(1:28:20) How software engineering is changing with AI
(1:36:12) Developer tools of the future
(1:39:00) Andrey’s advice for junior engineers and students
(1:42:32) Rapid fire round
—
The Pragmatic Engineer dee…
-
The third golden age of software engineering – thanks to AI, with Grady Booch
4 februari 2026 · 1 uur 17 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
Every few decades, software engineering is declared “dead” or on the verge of being automated away. We’ve heard versions of this story before. But what if it’s just the start of a new “golden age” of a different type of software engineering, like it has been many times before?
In this episode of The Pragmatic Engineer, I’m joined once again by Grady Booch, one of the most influential figures in the history of software engineering, to put today’s claims about AI and automation into historical context.
Grady is the co-creator of the Unified Modeling Language, author of several books and papers that have shaped modern software development, and Chief Scientist for Software Engineering at IBM, where he focuses on embodied cognition.
Grady shares his perspective on three golden ages of computing since the 1940s, and how each emerged in response to the constraints of its time. He explains how technical limits and human factors have always shaped the systems we build, and why periods of rapid change tend to produce both real progress and inflated expectations.
He also responds to current claims that software engineering will soon be fully automated, explaining why systems thinking, human judgment, and responsibility remain central to the work, even as tools continue to evolve.
—
Timestamps
(00:00) Intro
(01:04) The first golden age of software engineering
(18:05) The software crisis
(32:07) The second golden age of software engineering
(41:27) Y2K and the Dotcom crash
(44:53) Early AI
(46:40) The third golden age of software engineering
(50:54) Why software engineers will very much be needed
(57:52) Grady responds to Dario Amodei
(1:06:00) New skills engineers will need to succeed
(1:09:10) Resources for s…
-
The creator of Clawd: "I ship code I don't read"
28 januari 2026 · 1 uur 54 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
Peter Steinberger ships more code than I’ve seen a single person do: in January, he was at more than 6,600 commits alone. As he puts it: “From the commits, it might appear like it's a company. But it’s not. This is one dude sitting at home having fun."
How does he do it?
Peter Steinberger is the creator of Clawdbot (as of yesterday: renamed to Moltbot) and founder of PSPDFKit. Moltbot – a work-in-progress AI agent that shows what the future of Siri could be like – is currently the hottest AI project in the tech industry, with more searches on Google than Claude Code or Codex. I sat down with Peter in London to talk about what building software looks like when you go all-in with AI tools like Claude and Codex.
Peter’s background is fascinating. He built and scaled PSPDFKit into a global developer tools business. Then, after a three-year break, he returned to building. This time, LLMs and AI agents sit at the center of his workflow. We discuss what changes when one person can operate like a team and why closing the loop between code, tests, and feedback becomes a prerequisite for working effectively with AI.
We also go into how engineering judgment shifts with AI, how testing and planning evolve when agents are involved, and which skills and habits are needed to work effectively. This is a grounded conversation about real workflows and real tradeoffs, and about designing systems that can test and improve themselves.
—
Timestamps
(00:00) Intro
(01:07) How Peter got into tech
(08:27) PSPDFKit
(19:14) PSPDFKit’s tech stack and culture
(22:33) Enterprise pricing
(29:42) Burnout
(34:54) Peter finding his spark again
(43:02) Peter’s workflow
(49:10) Managing agents
(54:08) Agentic engineering
(59:01) Testi…
-
How AWS S3 is built
21 januari 2026 · 1 uur 18 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar – The makers of SonarQube, the industry standard for automated code review
• WorkOS – Everything you need to make your app enterprise ready.
—
Amazon S3 is one of the largest distributed systems ever built, storing and serving data for a significant portion of the internet. Behind its simple interfaces hides an enormous amount of engineering work, careful tradeoffs, and long-term thinking.
In this episode, I sit down with Mai-Lan Tomsen Bukovec, VP of Data and Analytics at AWS, who has been running Amazon S3 for more than a decade. Mai-Lan shares how S3 operates at extreme scale, what it takes to design for durability and availability across millions of servers, and why building for failure is a core principle.
We also go deep into how AWS approaches correctness using formal methods, how storage tiers and limits shape system design, and why simplicity remains one of the hardest and most important goals at S3’s scale.
—
Timestamps
(00:00) Intro
(01:03) S3’s scale
(03:58) How S3 started
(07:25) Parquet, Iceberg, and S3 tables
(09:46) S3 for developers
(13:37) Why AWS keeps S3 prices low
(17:10) AWS pricing tiers
(19:38) Availability and durability
(26:21) The cost of S3's consistency
(31:22) Automated reasoning and proof of correctness
(35:14) Durability at AWS scale
(39:58) Correlated failure and crash consistency
(43:22) Failure allowances
(46:04) Two opposing principles in S3 design
(49:09) S3’s evolution
(52:21) S3 Vectors
(1:01:16) The 50 TB limit on AWS
(1:07:54) The simplicity principle
(1:10:10) Types of engineers working on S3
(1:14:15) Closing recommendations
—
The Pragmatic Engineer deepdives relevant for this episode:
• Inside Amazon’s engineering culture
• How AWS deals with a major outage
• A Day in the Life of a Senior Manager at Amazon
• What is a Principal Engineer at Amazon? – with Steve Huynh
• Working at Am…
-
The history of servers, the cloud, and what’s next – with Oxide
17 december 2025 · 1 uur 39 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Linear — The system for modern product development.
—
How have servers and the cloud evolved in the last 30 years, and what might be next? Bryan Cantrill was a distinguished engineer at Sun Microsystems during both the Dotcom Boom and the Dotcom Bust. Today, he is the co-founder and CTO of Oxide Computer, where he works on modern server infrastructure.
In this episode of The Pragmatic Engineer, Bryan joins me to break down how modern computing infrastructure evolved. We discuss why the Dotcom Bust produced deeper innovation than the Boom, how constraints shape better systems, and what the rise of the cloud changed and did not change about building reliable infrastructure.
Our conversation covers early web infrastructure at Sun, the emergence of AWS, Kubernetes and cloud neutrality, and the tradeoffs between renting cloud space and building your own. We also touch on the complexity of server-side software updates, experimenting with AI, the limits of large language models, and how engineering organizations scale without losing their values.
If you want a systems-level perspective on computing that connects past cycles to today’s engineering decisions, this episode offers a rare long-range view.
—
Timestamps
(00:00) Intro
(01:26) Computer science in the 1990s
(03:01) Sun and Cisco’s web dominance
(05:41) The Dotcom Boom
(10:26) From Boom to Bust
(15:32) The innovations of the Bust
(17:50) The open source shift
(22:00) Oracle moves into Sun’s orbit
(24:54) AWS dominance (2010–2014)
(28:15) How Kubernetes and cloud neutrality
(30:58) Custom infrastructure
(36:10) Renting the cloud vs. buying hardware
(45:28) Designing a computer from first principles
(50:02) Why everyone is paid the same salary at Oxide
(54:14) Oxide’s software stack
(58:33) The evolution of software updates
(1:02:55) How Oxide uses AI
(1:06:05) The limitations of LLMs…
-
Being a founding engineer at an AI startup
3 december 2025 · 1 uur 4 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Linear — The system for modern product development.
—
Michelle Lim joined Warp as engineer number one and is now building her own startup, Flint. She brings a strong product-first mindset shaped by her time at Facebook, Slack, Robinhood, and Warp. Michelle shares why she chose Warp over safer offers, how she evaluates early-stage opportunities, and what she believes distinguishes great founding engineers.
Together, we cover how product-first engineers create value, why negotiating equity at early-stage startups requires a different approach, and why asking founders for references is a smart move. Michelle also shares lessons from building consumer and infrastructure products, how she thinks about tech stack choices, and how engineers can increase their impact by taking on work outside their job descriptions.
If you want to understand what founders look for in early engineers or how to grow into a founding-engineer role, this episode is full of practical advice backed by real examples
—
Timestamps
(00:00) Intro
(01:32) How Michelle got into software engineering
(03:30) Michelle’s internships
(06:19) Learnings from Slack
(08:48) Product learnings at Robinhood
(12:47) Joining Warp as engineer #1
(22:01) Negotiating equity
(26:04) Asking founders for references
(27:36) The top reference questions to ask
(32:53) The evolution of Warp’s tech stack
(35:38) Product-first engineering vs. code-first
(38:27) Hiring product-first engineers
(41:49) Different types of founding engineers
(44:42) How Flint uses AI tools
(45:31) Avoiding getting burned in founder exits
(49:26) Hiring top talent
(50:15) An overview of Flint
(56:08) Advice for aspiring founding engineers
(1:01:05) Rapid fire round
—
The Pragmatic Engineer deepdives relevant for this episode:
• Thriving as a founding engineer: lessons from the trenches
• From software engineer to …
-
Code security for software engineers
26 november 2025 · 1 uur 8 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more. Statsig are helping make the first-ever Pragmatic Summit a reality. Join me and 400 other top engineers and leaders on 11 February, in San Francisco for a special one-day event. Reserve your spot here.
• Linear — The system for modern product development. Engineering teams today move much faster, thanks to AI. Because of this, coordination increasingly becomes a problem. This is where Linear helps fast-moving teams stay focused. Check out Linear.
—
As software engineers, what should we know about writing secure code?
Johannes Dahse is the VP of Code Security at Sonar and a security expert with 20 years of industry experience. In today’s episode of The Pragmatic Engineer, he joins me to talk about what security teams actually do, what developers should own, and where real-world risk enters modern codebases.
We cover dependency risk, software composition analysis, CVEs, dynamic testing, and how everyday development practices affect security outcomes. Johannes also explains where AI meaningfully helps, where it introduces new failure modes, and why understanding the code you write and ship remains the most reliable defense.
If you build and ship software, this episode is a practical guide to thinking about code security under real-world engineering constraints.
—
Timestamps
(00:00) Intro
(02:31) What is penetration testing?
(06:23) Who owns code security: devs or security teams?
(14:42) What is code security?
(17:10) Code security basics for devs
(21:35) Advanced security challenges
(24:36) SCA testing
(25:26) The CVE Program
(29:39) The State of Code Security report
(32:02) Code quality vs security
(35:20) Dev machines as a security vulnerability
(37:29) Common security tools
(42:50) Dynamic security tools
(45:01) AI security reviews: what are the limits?
(47:51) AI-generated code risks
(49:21) More code: more vulnerabilities
(51:44) AI…
-
How AI will change software engineering – with Martin Fowler
19 november 2025 · 1 uur 49 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more. AI-accelerated development isn’t just about shipping faster: it’s about measuring whether, what you ship, actually delivers value. This is where modern experimentation with Statsig comes in. Check it out.
• Linear — The system for modern product development. I had a jaw-dropping experience when I dropped in for the weekly “Quality Wednesdays” meeting at Linear. Every week, every dev fixes at least one quality isse, large or small. Even if it’s one pixel misalignment, like this one. I’ve yet to see a team obsess this much about quality. Read more about how Linear does Quality Wednesdays – it’s fascinating!
—
Martin Fowler is one of the most influential people within software architecture, and the broader tech industry. He is the Chief Scientist at Thoughtworks and the author of Refactoring and Patterns of Enterprise Application Architecture, and several other books. He has spent decades shaping how engineers think about design, architecture, and process, and regularly publishes on his blog, MartinFowler.com.
In this episode, we discuss how AI is changing software development: the shift from deterministic to non-deterministic coding; where generative models help with legacy code; and the narrow but useful cases for vibe coding. Martin explains why LLM output must be tested rigorously, why refactoring is more important than ever, and how combining AI tools with deterministic techniques may be what engineering teams need.
We also revisit the origins of the Agile Manifesto and talk about why, despite rapid changes in tooling and workflows, the skills that make a great engineer remain largely unchanged.
—
Timestamps
(00:00) Intro
(01:50) How Martin got into software engineering
(07:48) Joining Thoughtworks
(10:07) The Thoughtworks Technology Radar
(16:45) From Assembly to high-level languages
(25:08) Non-determinism
(33:38) Vibe coding
(39:22) StackO…
-
Netflix’s Engineering Culture
12 november 2025 · 1 uur
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more. Statsig enables two cultures at once: continuous shipping and experimentation. Companies like Notion went from single-digit experiments per quarter to over 300 experiments with Statsig. Start using Statsig with a generous free tier, and a $50K startup program.
• Linear — The system for modern product development. When most companies hit real scale, they start to slow down, and are faced with “process debt.” This often hits software engineers the most. Companies switch to Linear to hit a hard reset on this process debt – ones like Scale cut their bug resolution in half after the switch. Check out Linear’s migration guide for details.
—
What’s it like to work as a software engineer inside one of the world’s biggest streaming companies?
In this special episode recorded at Netflix’s headquarters in Los Gatos, I sit down with Elizabeth Stone, Netflix’s Chief Technology Officer. Before becoming CTO, Elizabeth led data and insights at Netflix and was VP of Science at Lyft. She brings a rare mix of technical depth, product thinking, and people leadership.
We discuss what it means to be “unusually responsible” at Netflix, how engineers make decisions without layers of approval, and how the company balances autonomy with guardrails for high-stakes projects like Netflix Live. Elizabeth shares how teams self-reflect and learn from outages and failures, why Netflix doesn’t do formal performance reviews, and what new grads bring to a company known for hiring experienced engineers.
This episode offers a rare inside look at how Netflix engineers build, learn, and lead at a global scale.
—
Timestamps
(00:00) Intro
(01:44) The scale of Netflix
(03:31) Production software stack
(05:20) Engineering challenges in production
(06:38) How the Open Connect delivery network works
(08:30) From pitch to play
(11:31) How Netflix enables engineers to make decisions
(13:26)…
-
From Swift to Mojo and high-performance AI Engineering with Chris Lattner
5 november 2025 · 1 uur 32 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more. Companies like Graphite, Notion, and Brex rely on Statsig to measure the impact of the pace they ship. Get a 30-day enterprise trial here.
• Linear – The system for modern product development. Linear is a heavy user of Swift: they just redesigned their native iOS app using their own take on Apple’s Liquid Glass design language. The new app is about speed and performance – just like Linear is. Check it out.
—
Chris Lattner is one of the most influential engineers of the past two decades. He created the LLVM compiler infrastructure and the Swift programming language – and Swift opened iOS development to a broader group of engineers. With Mojo, he’s now aiming to do the same for AI, by lowering the barrier to programming AI applications.
I sat down with Chris in San Francisco, to talk language design, lessons on designing Swift and Mojo, and – of course! – compilers. It’s hard to find someone who is as enthusiastic and knowledgeable about compilers as Chris is!
We also discussed why experts often resist change even when current tools slow them down, what he learned about AI and hardware from his time across both large and small engineering teams, and why compiler engineering remains one of the best ways to understand how software really works.
—
Timestamps
(00:00) Intro
(02:35) Compilers in the early 2000s
(04:48) Why Chris built LLVM
(08:24) GCC vs. LLVM
(09:47) LLVM at Apple
(19:25) How Chris got support to go open source at Apple
(20:28) The story of Swift
(24:32) The process for designing a language
(31:00) Learnings from launching Swift
(35:48) Swift Playgrounds: making coding accessible
(40:23) What Swift solved and the technical debt it created
(47:28) AI learnings from Google and Tesla
(51:23) SiFive: learning about hardware engineering
(52:24) Mojo’s origin story
(57:15) Modular’s bet on a two-level stack
(1:01:49) Compiler shortcomin…
-
Beyond Vibe Coding with Addy Osmani
29 oktober 2025 · 1 uur 8 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Linear – The system for modern product development.
—
Addy Osmani is Head of Chrome Developer Experience at Google, where he leads teams focused on improving performance, tooling, and the overall developer experience for building on the web. If you’ve ever opened Chrome’s Developer Tools bar, you’ve definitely used features Addy has built. He’s also the author of several books, including his latest, Beyond Vibe Coding, which explores how AI is changing software development.
In this episode of The Pragmatic Engineer, I sit down with Addy to discuss how AI is reshaping software engineering workflows, the tradeoffs between speed and quality, and why understanding generated code remains critical. We dive into his article The 70% Problem, which explains why AI tools accelerate development but struggle with the final 30% of software quality—and why this last 30% is tackled easily by software engineers who understand how the system actually works.
—
Timestamps
(00:00) Intro
(02:17) Vibe coding vs. AI-assisted engineering
(06:07) How Addy uses AI tools
(13:10) Addy’s learnings about applying AI for development
(18:47) Addy’s favorite tools
(22:15) The 70% Problem
(28:15) Tactics for efficient LLM usage
(32:58) How AI tools evolved
(34:29) The case for keeping expectations low and control high
(38:05) Autonomous agents and working with them
(42:49) How the EM and PM role changes with AI
(47:14) The rise of new roles and shifts in developer education
(48:11) The importance of critical thinking when working with AI
(54:08) LLMs as a tool for learning
(1:03:50) Rapid questions
—
The Pragmatic Engineer deepdives relevant for this episode:
• Vibe Coding as a software engineer
• How AI-assisted coding will change software engineering: hard truths
• AI Engineering in the real world
• The AI Engineering stack
• How Claude Code is built
—
Produ…
-
Google’s engineering culture
15 oktober 2025 · 2 uur 46 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more. Something interesting is happening with the latest generation of tech giants. Rather than building advanced experimentation tools themselves, companies like Anthropic, Figma, Notion and a bunch of others… are just using Statsig. Statsig has rebuilt this entire suite of data tools that was available at maybe 10 or 15 giants until now. Check out Statsig.
• Linear – The system for modern product development. Linear is just so fast to use – and it enables velocity in product workflows. Companies like Perplexity and OpenAI have already switched over, because simplicity scales. Go ahead and check out Linear and see why it feels like a breeze to use.
—
What is it really like to be an engineer at Google?
In this special deep dive episode, we unpack how engineering at Google actually works. We spent months researching the engineering culture of the search giant, and talked with 20+ current and former Googlers to bring you this deepdive with Elin Nilsson, tech industry researcher for The Pragmatic Engineer and a former Google intern.
Google has always been an engineering-driven organization. We talk about its custom stack and tools, the design-doc culture, and the performance and promotion systems that define career growth. We also explore the culture that feels built for engineers: generous perks, a surprisingly light on-call setup often considered the best in the industry, and a deep focus on solving technical problems at scale.
If you are thinking about applying to Google or are curious about how the company’s engineering culture has evolved, this episode takes a clear look at what it was like to work at Google in the past versus today, and who is a good fit for today’s Google.
Jump to interesting parts:
(13:50) Tech stack
(1:05:08) Performance reviews (GRAD)
(2:07:03) The culture of continuously rewriting things
—
Timestamps
(00:00) Intro
(01:44) Stats ab…
-
Python, Go, Rust, TypeScript and AI with Armin Ronacher
8 oktober 2025 · 1 uur 14 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more. Most teams end up in this situation: ship a feature to 10% of users, wait a week, check three different tools, try to correlate the data, and you’re still unsure if it worked. The problem is that each tool has its own user identification and segmentation logic. Statsig solved this problem by building everything within a unified platform. Check out Statsig.
• Linear – The system for modern product development. In the episode, Armin talks about how he uses an army of “AI interns” at his startup. With Linear, you can easily do the same: Linear’s Cursor integration lets you add Cursor as an agent to your workspace. This agent then works alongside you and your team to make code changes or answer questions. You’ve got to try it out: give Linear a spin and see how it integrates with Cursor.
—
Armin Ronacher is the creator of the Flask framework for Python, was one of the first engineers hired at Sentry, and now the co-founder of a new startup. He has spent his career thinking deeply about how tools shape the way we build software.
In this episode of The Pragmatic Engineer Podcast, he joins me to talk about how programming languages compare, why Rust may not be ideal for early-stage startups, and how AI tools are transforming the way engineers work. Armin shares his view on what continues to make certain languages worth learning, and how agentic coding is driving people to work more, sometimes to their own detriment.
We also discuss:
• Why the Python 2 to 3 migration was more challenging than expected
• How Python, Go, Rust, and TypeScript stack up for different kinds of work
• How AI tools are changing the need for unified codebases
• What Armin learned about error handling from his time at Sentry
• And much more
Jump to interesting parts:
• (06:53) How Python, Go, and Rust stack up and when to use each one
• (30:08) Why Armin has changed his mind about AI …
-
Hypergrowth startups: Uber and CloudKitchens with Charles-Axel Dein
24 september 2025 · 1 uur 44 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more. Statsig built a complete set of data tools that allow engineering teams to measure the impact of their work. This toolkit is SO valuable to so many teams, that OpenAI - who was a huge user of Statsig - decided to acquire the company, the news announced last week. Talk about validation! Check out Statsig.
• Linear – The system for modern product development. Here’s an interesting story: OpenAI switched to Linear as a way to establish a shared vocabulary between teams. Every project now follows the same lifecycle, uses the same labels, and moves through the same states. Try Linear for yourself.
—
What does it take to do well at a hyper-growth company? In this episode of The Pragmatic Engineer, I sit down with Charles-Axel Dein, one of the first engineers at Uber, who later hired me there. Since then, he’s gone on to work at CloudKitchens. He’s also been maintaining the popular Professional programming reading list GitHub repo for 15 years, where he collects articles that made him a better programmer.
In our conversation, we dig into what it’s really like to work inside companies that grow rapidly in scale and headcount. Charles shares what he’s learned about personal productivity, project management, incidents, interviewing, plus how to build flexible skills that hold up in fast-moving environments.
Jump to interesting parts:
• 10:41 – the reality of working inside a hyperscale company
• 41:10 – the traits of high-performing engineers
• 1:03:31 – Charles’ advice for getting hired in today’s job market
We also discuss:
• How to spot the signs of hypergrowth (and when it’s slowing down)
• What sets high-performing engineers apart beyond shipping
• Charles’s personal productivity tips, favorite reads, and how he uses reading to uplevel his skills
• Strategic tips for building your resume and interviewing
• How imposter syndrome is normal, and how leaning…
-
Code Complete with Steve McConnell
10 september 2025 · 1 uur 30 min
Brought to You By: Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more. Statsig built a complete set of data tools that allow engineering teams to measure the impact of their work. This toolkit is SO valuable to so many teams, that OpenAI - who was a huge user of Statsig - decided to acquire the company, the news announced last week. Talk about validation! Check out Statsig.
• Linear – The system for modern product development. Here’s an interesting story: OpenAI switched to Linear as a way to establish a shared vocabulary between teams. Every project now follows the same lifecycle, uses the same labels, and moves through the same states. Try Linear for yourself.
—
The Pragmatic Engineer Podcast is back with the Fall 2025 season. Expect new episodes to be published on most Wednesdays, looking ahead.
Code Complete is one of the most enduring books on software engineering. Steve McConnell wrote the 900-page handbook just five years into his career, capturing what he wished he’d known when starting out. Decades later, the lessons remain relevant, and Code Complete remains a best-seller.
In this episode, we talk about what has aged well, what needed updating in the second edition, and the broader career principles Steve has developed along the way. From his “career pyramid” model to his critique of “lily pad hopping,” and why periods of working in fast-paced, all-in environments can be so rewarding, the emphasis throughout is on taking ownership of your career and making deliberate choices.
We also discuss:
• Top-down vs. bottom-up design and why most engineers default to one approach
• Why rewriting code multiple times makes it better
• How taking a year off to write Code Complete crystallized key lessons
• The 3 areas software designers need to understand, and why focusing only on technology may be the most limiting
• And much more!
Steve rarely gives interviews, so I hope you enjoy this conversation, which we recorded in S…
-
The state of VC within software and AI startups – with Peter Walker
6 augustus 2025 · 1 uur 20 min
Brought to You By: Lees meer
• WorkOS — The modern identity platform for B2B SaaS.
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar — Code quality and code security for ALL code.
—
In this episode of The Pragmatic Engineer, I sit down with Peter Walker, Head of Insights at Carta, to break down how venture capital and startups themselves are changing.
We go deep on the numbers: why fewer companies are getting funded despite record VC investment levels, how hiring has shifted dramatically since 2021, and why solo founders are on the rise even though most VCs still prefer teams. We also unpack the growing emphasis on ARR per FTE, what actually happens in bridge and down rounds, and why the time between fundraising rounds has stretched far beyond the old 18-month cycle.
We cover what all this means for engineers: what to ask before joining a startup, how to interpret valuation trends, and what kind of advisor roles startups are actually looking for.
If you work at a startup, are considering joining one, or just want a clearer picture of how venture-backed companies operate today, this episode is for you.
—
Timestamps
(00:00) Intro
(01:21) How venture capital works and the goal of VC-backed startups
(03:10) Venture vs. non-venture backed businesses
(05:59) Why venture-backed companies prioritize growth over profitability
(09:46) A look at the current health of venture capital
(13:19) The hiring slowdown at startups
(16:00) ARR per FTE: The new metric VCs care about
(21:50) Priced seed rounds vs. SAFEs
(24:48) Why some founders are incentivized to raise at high valuations
(29:31) What a bridge round is and why they can signal trouble
(33:15) Down rounds and how optics can make or break startups
(36:47) Why working at startups offers more ownership and learning
(37:47) What the data shows about raising money in the summer
(41:45) The length of time it takes to close a VC deal
(44:29) How AI is reshaping startup for…
-
Measuring the impact of AI on software engineering – with Laura Tacho
23 juli 2025 · 1 uur 12 min
Supported by Our Partners Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Graphite — The AI developer productivity platform.
—
There’s no shortage of bold claims about AI and developer productivity, but how do you separate signal from noise?
In this episode of The Pragmatic Engineer, I’m joined by Laura Tacho, CTO at DX, to cut through the hype and share how well (or not) AI tools are actually working inside engineering orgs. Laura shares insights from DX’s research across 180+ companies, including surprising findings about where developers save the most time, why devs don’t use AI at all, and what kinds of rollouts lead to meaningful impact.
We also discuss:
• The problem with oversimplified AI headlines and how to think more critically about them
• An overview of the DX AI Measurement framework
• Learnings from Booking.com’s AI tool rollout
• Common reasons developers aren’t using AI tools
• Why using AI tools sometimes decreases developer satisfaction
• Surprising results from DX’s 180+ company study
• How AI-generated documentation differs from human-written docs
• Why measuring developer experience before rolling out AI is essential
• Why Laura thinks roadmaps are on their way out
• And much more!
—
Timestamps
(00:00) Intro
(01:23) Laura’s take on AI overhyped headlines
(10:46) Common questions Laura gets about AI implementation
(11:49) How to measure AI’s impact
(15:12) Why acceptance rate and lines of code are not sufficient measures of productivity
(18:03) The Booking.com case study
(20:37) Why some employees are not using AI
(24:20) What developers are actually saving time on
(29:14) What happens with the time savings
(31:10) The surprising results from the DORA report on AI in engineering
(33:44) A hypothesis around AI and flow state and the importance of talking to developers
(35:59) What’s working in AI architecture
(42:22) Learnings from WorkHuman’s adoption of Copilot
(47:00) Consump…
-
Amazon, Google and Vibe Coding with Steve Yegge
16 juli 2025 · 1 uur 34 min
Supported by Our Partners Lees meer
• WorkOS — The modern identity platform for B2B SaaS.
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar — Code quality and code security for ALL code.
—
Steve Yegge is known for his writing and “rants”, including the famous “Google Platforms Rant” and the evergreen “Get that job at Google” post. He spent 7 years at Amazon and 13 at Google, as well as some time at Grab before briefly retiring from tech. Now out of retirement, he’s building AI developer tools at Sourcegraph—drawn back by the excitement of working with LLMs. He’s currently writing the book Vibe Coding: Building Production-Grade Software With GenAI, Chat, Agents, and Beyond.
In this episode of The Pragmatic Engineer, I sat down with Steve in Seattle to talk about why Google consistently failed at building platforms, why AI coding feels easy but is hard to master, and why a new role, the AI Fixer, is emerging. We also dig into why he’s so energized by today’s AI tools, and how they’re changing the way software gets built.
We also discuss:
• The “interview anti-loop” at Google and the problems with interviews
• An inside look at how Amazon operated in the early days before microservices
• What Steve liked about working at Grab
• Reflecting on the Google platforms rant and why Steve thinks Google is still terrible at building platforms
• Why Steve came out of retirement
• The emerging role of the “AI Fixer” in engineering teams
• How AI-assisted coding is deceptively simple, but extremely difficult to steer
• Steve’s advice for using AI coding tools and overcoming common challenges
• Predictions about the future of developer productivity
• A case for AI creating a real meritocracy
• And much more!
—
Timestamps
(00:00) Intro
(04:55) An explanation of the interview anti-loop at Google and the shortcomings of interviews
(07:44) Work trials and why entry-level jobs aren’t posted for big tech companies
(09:50) An over…
-
What is a Principal Engineer at Amazon? With Steve Huynh
9 juli 2025 · 1 uur 13 min
Supported by Our Partners Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Graphite — The AI developer productivity platform.
• Augment Code — AI coding assistant that pro engineering teams love.
—
Steve Huynh spent 17 years at Amazon, including four as a Principal Engineer. In this episode of The Pragmatic Engineer, I join Steve in his studio for a deep dive into what the Principal role actually involves, why the path from Senior to Principal is so tough, and how even strong engineers can get stuck. Not because they’re unqualified, but because the bar is exceptionally high.
We discuss what’s expected at the Principal level, the kind of work that matters most, and the trade-offs that come with the title. Steve also shares how Amazon’s internal policies shaped his trajectory, and what made the Principal Engineer community one of the most rewarding parts of his time at the company.
We also go into:
• Why being promoted from Senior to Principal is one of the hardest jumps in tech
• How Amazon’s freedom of movement policy helped Steve work across multiple teams, from Kindle to Prime Video
• The scale of Amazon: handling 10k–100k+ requests per second and what that means for engineering
• Why latency became a company-wide obsession—and the research that tied it directly to revenue
• Why companies should start with a monolith, and what led Amazon to adopt microservices
• What makes the Principal Engineering community so special
• Amazon’s culture of learning from its mistakes, including COEs (correction of errors)
• The pros and cons of the Principal Engineer role
• What Steve loves about the leadership principles at Amazon
• Amazon’s intense writing culture and 6-pager format
• Why Amazon patents software and what that process looks like
• And much more!
—
Timestamps
(00:00) Intro
(01:11) What Steve worked on at Amazon, including Kindle, Prime Video, and payments
(04:38) How Steve was able to work on so many tea…
-
How AI is changing software engineering at Shopify with Farhan Thawar
2 juli 2025 · 47 min
Supported by Our Partners Lees meer
• WorkOS — The modern identity platform for B2B SaaS.
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Sonar — Code quality and code security for ALL code.
—
What happens when a company goes all in on AI?
At Shopify, engineers are expected to utilize AI tools, and they’ve been doing so for longer than most. Thanks to early access to models from GitHub Copilot, OpenAI, and Anthropic, the company has had a head start in figuring out what works.
In this live episode from LDX3 in London, I spoke with Farhan Thawar, VP of Engineering, about how Shopify is building with AI across the entire stack. We cover the company’s internal LLM proxy, its policy of unlimited token usage, and how interns help push the boundaries of what’s possible.
In this episode, we cover:
• How Shopify works closely with AI labs
• The story behind Shopify’s recent Code Red
• How non-engineering teams are using Cursor for vibecoding
• Tobi Lütke’s viral memo and Shopify’s expectations around AI
• A look inside Shopify’s LLM proxy—used for privacy, token tracking, and more
• Why Shopify places no limit on AI token spending
• Why AI-first isn’t about reducing headcount—and why Shopify is hiring 1,000 interns
• How Shopify’s engineering department operates and what’s changed since adopting AI tooling
• Farhan’s advice for integrating AI into your workflow
• And much more!
—
Timestamps
(00:00) Intro
(02:07) Shopify’s philosophy: “hire smart people and pair with them on problems”
(06:22) How Shopify works with top AI labs
(08:50) The recent Code Red at Shopify
(10:47) How Shopify became early users of GitHub Copilot and their pivot to trying multiple tools
(12:49) The surprising ways non-engineering teams at Shopify are using Cursor
(14:53) Why you have to understand code to submit a PR at Shopify
(16:42) AI tools' impact on SaaS
(19:50) Tobi Lütke’s AI memo
(21:46) Shopify’s LLM proxy and how they protect their…
-
The present, past and future of GitHub
18 juni 2025 · 1 uur 27 min
Supported by Our Partners Lees meer
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Graphite — The AI developer productivity platform.
• Augment Code — AI coding assistant that pro engineering teams love
—
GitHub recently turned 17 years old—but how did it start, how has it evolved, and what does the future look like as AI reshapes developer workflows?
In this episode of The Pragmatic Engineer, I’m joined by Thomas Dohmke, CEO of GitHub. Thomas has been a GitHub user for 16 years and an employee for 7. We talk about GitHub’s early architecture, its remote-first operating model, and how the company is navigating AI—from Copilot to agents. We also discuss why GitHub hires junior engineers, how the company handled product-market fit early on, and why being a beloved tool can make shipping harder at times.
Other topics we discuss include:
• How GitHub’s architecture evolved beyond its original Rails monolith
• How GitHub runs as a remote-first company—and why they rarely use email
• GitHub’s rigorous approach to security
• Why GitHub hires junior engineers
• GitHub’s acquisition by Microsoft
• The launch of Copilot and how it’s reshaping software development
• Why GitHub sees AI agents as tools, not a replacement for engineers
• And much more!
—
Timestamps
(00:00) Intro
(02:25) GitHub’s modern tech stack
(08:11) From cloud-first to hybrid: How GitHub handles infrastructure
(13:08) How GitHub’s remote-first culture shapes its operations
(18:00) Former and current internal tools including Haystack
(21:12) GitHub’s approach to security
(24:30) The current size of GitHub, including security and engineering teams
(25:03) GitHub’s intern program, and why they are hiring junior engineers
(28:27) Why AI isn’t a replacement for junior engineers
(34:40) A mini-history of GitHub
(39:10) Why GitHub hit product market fit so quickly
(43:44) The invention of pull requests
(44:50) How GitHub enables offline work
(46:21) How mo…
-
TDD, AI agents and coding with Kent Beck
11 juni 2025 · 1 uur 16 min
Supported by Our Partners Lees meer
• Sonar — Code quality and code security for ALL code.
• Statsig — The unified platform for flags, analytics, experiments, and more.
• Augment Code — AI coding assistant that pro engineering teams love.
—
Kent Beck is one of the most influential figures in modern software development. Creator of Extreme Programming (XP), co-author of The Agile Manifesto, and a pioneer of Test-Driven Development (TDD), he’s shaped how teams write, test, and think about code.
Now, with over five decades of programming experience, Kent is still pushing boundaries—this time with AI coding tools. In this episode of Pragmatic Engineer, I sit down with him to talk about what’s changed, what hasn’t, and why he’s more excited than ever to code.
In our conversation, we cover:
• Why Kent calls AI tools an “unpredictable genie”—and how he’s using them
• Why Kent no longer has an emotional attachment to any specific programming language
• The backstory of The Agile Manifesto—and why Kent resisted the word “agile”
• An overview of XP (Extreme Programming) and how Grady Booch played a role in the name
• Tape-to-tape experiments in Kent’s childhood that laid the groundwork for TDD
• Kent’s time at Facebook and how he adapted to its culture and use of feature flags
• And much more!
—
Timestamps
(00:00) Intro
(02:27) What Kent has been up to since writing Tidy First
(06:05) Why AI tools are making coding more fun for Kent and why he compares it to a genie
(13:41) Why Kent says languages don’t matter anymore
(16:56) Kent’s current project building a small talk server
(17:51) How Kent got involved with The Agile Manifesto
(23:46) Gergely’s time at JP Morgan, and why Kent didn’t like the word ‘agile’
(26:25) An overview of “extreme programming” (XP)
(35:41) Kent’s childhood tape-to-tape experiments that inspired TDD
(42:11) Kent’s response to Ousterhout’s criticism of TDD
(50:05) Why Kent still uses TDD with his AI stack
(54:26) How Facebook op…