The Pragmatic Engineer Podcast

Why performant code matters (but gets widely ignored), with Casey Muratori

CMCasey Muratori

Our page for this episode →Watch on youtube.com ↗

• 0:18:28 Performance cannot win a market on its own: against an incumbent held up by network effects, being far more responsive is a nice plus and nothing more.
• 0:19:45 A decade of arguing that software is too slow has started to work: new products are now attacking established categories on a performance pitch alone, and getting traction.
• 0:20:51 A 300-millisecond response budget is not an achievement but an admission: 300 milliseconds is an eternity in computing, and a product pitching it shows how far the bar has fallen.
• 0:21:36 The software industry is massively underperforming its hardware, by factors of ten to a hundred, and people refuse to believe the numbers when you say them.
• 0:24:09 Optimization means measuring the gap between your code and what the hardware could theoretically do, not making changes and checking whether the statistics improved.
• 0:27:37 Source code in any language tells you nothing about what the CPU is actually asked to do; only the compiler's assembly output does, and reading it is a skill every serious programmer should have.

All 26 from this episode, along the running time →

From Chrome DevTools to AI Engineering, with Addy Osmani

AOAddy Osmani

Our page for this episode →Watch on youtube.com ↗

• 0:14:00 Computing is an onion, and the more layers of it you can peel back and understand, the better you can build for the constrained machines real people are using.
• 0:29:39 Very few developers understand memory management, and that is why the state of the art in memory debugging has barely moved in years.
• 0:37:10 Performance work used to mean half a day reading traces before writing a single fix, and language models have collapsed that step to minutes.
• 0:41:46 "Is the page loaded?" was never a real question, and web performance only became measurable once it was broken into the distinct moments a user actually notices.
• 0:43:29 People treat an unresponsive interface exactly the way they treat a slow pedestrian crossing: they keep hitting the button.
• 0:44:05 A site's need to monetise is not a defence of an experience that shifts the page under the reader; those are separate questions.

All 22 from this episode, along the running time →

Stop being skeptical about AI for development with Charity Majors

CMCharity Majors

Our page for this episode →Watch on youtube.com ↗

• 0:07:24 Team output is still what matters, however hard the industry pushes to measure individual output.
• 0:08:01 Equating better with faster is a very immature description of what better means.
• 0:10:31 The step change in AI coding in 2025 came from the harnesses and the tooling around the models, not from the models themselves.
• 0:12:04 There is no point arguing about whether or when engineers will ship code they have not read; the only useful question is what it would take.
• 0:14:55 You can now generate ten thousand variants of a function faster than you could write it once, and that economics pushes software towards replacement rather than repair.
• 0:17:03 Lines of code are the wrong artifact to review; what we should be storing and reviewing is an architecture that generates the code to spec.

All 26 from this episode, along the running time →

Formal methods with Hillel Wayne

HWHillel Wayne

Our page for this episode →Watch on youtube.com ↗

• 0:07:09 Every branch of engineering hates waterfall, not just software.
• 0:07:18 The core tension of all engineering is between how expensive a mistake is and how quickly you can iterate, and that alone decides how much planning a field does.
• 0:08:30 Software did not invent iterative development: mining engineers had their Agile revolution in 1960.
• 0:12:11 Software is the only field of human labour with practitioner conferences and freely shared knowledge; every other field has only academic conferences and trade shows.
• 0:15:07 Version control is the one thing every traditional engineer wishes their old field had.
• 0:15:54 Software iterates better than every other engineering field and plans worse than all of them.

All 24 from this episode, along the running time →

Context engineering with Dex Horthy

DHDex Horthy

Our page for this episode →Watch on youtube.com ↗

• 0:21:28 Every abstraction in agentic programming — RAG, memory, agentic history, structured output — is just a different way of passing tokens into a model, and understanding that beats learning any of them.
• 0:26:43 Harness engineering is raising the floor: optimising the environment a coding agent runs in so that the results of every single turn are as good as possible.
• 0:27:52 Context engineering has stayed relevant for a year because it is grounded in how transformer attention works, and it will matter to anyone building on AI until post-transformer models arrive.
• 0:29:05 A bigger context window does not give you a smarter model; the intelligence of the model is what decides how much of that window it can actually attend to.
• 0:30:15 Context has two budgets, not one: the information budget everyone thinks about, and an instruction budget, where conflicting instructions cost the model real computation to ignore.
• 0:32:15 The engineering intuition that matters cannot be taught from a textbook — you know bad patterns in software because you have debugged them at three in the morning.

All 26 from this episode, along the running time →

How Kent Beck shapes the software engineering industry

KBKent Beck

Our page for this episode →Watch on youtube.com ↗

• 0:04:00 Saying that coding will be automated away first betrays a misunderstanding of software engineering, because coding is only a small part of the work.
• 0:05:08 The industry is now accumulating code faster than it is accumulating trust, and trust only comes from having struggled to understand the domain yourself.
• 0:07:42 Engineers were promised that understanding the computer would be enough, and the human skills they were told they could skip turn out to be the hard part.
• 0:23:57 Letting non-programmers build their own unmaintainable software is still a large step forward, because the alternative was a thousand-page requirements document and an eight-year wait.
• 0:37:05 Programs exist to communicate intent to other people and now to models as well, and we do not understand at all how to communicate effectively to models.
• 0:43:00 An outside expert's understanding of somebody else's problem is bounded, because they do not have to live with the design after they leave.

  design

All 28 from this episode, along the running time →

Tech interviews with NeetCode

NENeetCode

Our page for this episode →Watch on youtube.com ↗

• 0:04:26 The data-structures-and-algorithms interview never tested a skill that transfers to the job; what it tested was whether somebody can think.
• 0:04:41 The coding interview has survived because companies have no idea how to evaluate candidates, and they probably never did.
• 0:05:45 What blocks big companies from changing their interview process is interviewer training: most interviewers are not good at interviewing and hate doing it.
• 0:06:29 New interview formats are coming, but the transition away from the coding interview will be slower than most people think.
• 0:11:29 Nobody should still be learning the CAP theorem, because the theorem that replaced it is more complete, no more complicated, and simpler to understand.
• 0:21:42 Promotion at a big company is mostly about landing the right team and the right project: a 100x engineer put on easy work has no hard problem to point at.

All 21 from this episode, along the running time →

Kubernetes and retiring at the top with Kelsey Hightower

KHKelsey Hightower

Our page for this episode →Watch on youtube.com ↗

• 0:18:52 Entrepreneurship is over-glorified: a parts-and-service business has none of the upside people imagine, because it does not grow the way a software company does.
• 0:32:22 Being an all-star at the activity is not impact: the measure is whether the team's queue is empty, not how many calls you personally took.
• 1:01:56 Every talk you give is a job interview, because an audience is reading what you are as much as what you are saying.

  hiring

• 1:16:31 Kubernetes won because Docker had already won: it inherited the one container runtime the whole industry had agreed on, instead of shipping another.
• 1:16:56 Docker Swarm lost because it stretched a single-node API across a cluster, and no amount of bolted-on storage and networking could repair that choice.
• 1:19:51 The real shift Kubernetes made was from infrastructure as code to infrastructure as data: you declare the object and control loops reconcile it, instead of running a program.

  infrastructure

All 28 from this episode, along the running time →

Building OpenCode with Dax Raad

Dax Raad

Our page for this episode →Watch on youtube.com ↗

• 0:04:58 Before product-market fit, coding faster does not help: it is better to think a lot than to swing a lot, and AI does not speed up the thinking.
• 0:05:41 Answering every problem, competitor and user request with one more shipped feature does not add up to a good product; it adds up to a horrible one.
• 0:05:52 Shipping ten times as much is not an advantage, because the moment you ship something you are stuck supporting it forever and every later feature has to interact with it.
• 0:06:44 Nobody in the coding-agent market is using AI so much better than everyone else that their competitors cannot keep up — the gap you would expect to see simply is not there.
• 0:18:32 In every developer-tool category — databases, compilers, whatever — the open source option eventually becomes the default option.

  open source

• 0:25:18 A small company's most reliable play is to pick one temporary bad guy and galvanise all of their competitors into pushing something forward against them.

All 24 from this episode, along the running time →

Why Rust is different, with Alice Ryhl

ARAlice Ryhl

Our page for this episode →Watch on youtube.com ↗

• 0:05:24 Rust's defining experience is that once the code compiles it works — not literally true, but true often enough that people keep saying it.
• 0:05:48 A language can only give you the feeling that compiling means working if it has a type system — that is where it all starts.
• 0:08:06 For a TypeScript team, Rust belongs on the backend — API servers — and not in the front end.

  TypeScript

• 0:10:12 Examples in documentation should be compiled and run as tests, so that changing the code breaks the docs instead of quietly outdating them.

  documentation

• 0:12:15 A compiler that names every place a change breaks turns refactoring into fixing errors until the compiler stops shouting.
• 0:13:47 The case for Rust is stronger against C++ than against JavaScript, because in C++ an ordinary mistake is usually a security vulnerability.

  JavaScriptcybersecurity

All 23 from this episode, along the running time →

TypeScript, C# and Turbo Pascal with Anders Hejlsberg

AHAnders Hejlsberg

Our page for this episode →Watch on youtube.com ↗

• 0:09:10 A programming language is not a compiler but an experience: editing, running, debugging and the runtime library all have to fit together as one cycle.
• 0:11:17 Turbo Pascal won because it was ten times better at a tenth of the price — faster, smaller, more interactive and cheaper at once.
• 0:17:39 It is a bad strategy to bet your development platform on technology licensed from a competitor.
• 0:19:49 C# exists because developers wanted both things at once: the power and productivity of C++ with the ease of use of Visual Basic.
• 0:22:03 A language should be designed by a small group of people rather than by one person.
• 0:22:41 Language design is ninety per cent the same work every time and ten per cent new, which is why the experience carries from one language to the next.

  design

All 26 from this episode, along the running time →

Designing Data-intensive Applications with Martin Kleppmann

MKMartin Kleppmann

Our page for this episode →Watch on youtube.com ↗

• 0:23:17 Reliability in a data system means fault tolerance above all: the system keeps working when a network link is cut or a node dies.
• 0:24:01 Scalability is not a property a system has; it is the set of mechanisms it has for coping with a change in load.
• 0:25:37 Scaling down is half of scalability: cost and capacity should track load in both directions, right down to a service that is nearly free to run.
• 0:29:38 Building databases on object stores is a genuine architectural break, because replication moves out of the database and into the storage layer.
• 0:31:55 An engineer writing business logic loses nothing by not understanding the layer underneath, exactly as they lose nothing by not managing memory.
• 0:32:17 Higher-level abstractions do not abolish low-level knowledge; they concentrate it in the smaller group of people who build the abstractions.

All 26 from this episode, along the running time →

DHH’s new way of writing code

David Heinemeier Hansson

Our page for this episode →Watch on youtube.com ↗

• 0:04:57 Rails is having a renaissance because it is one of the most token-efficient ways to build a web app, which suits agents, for as long as that lasts.

  Ruby on Railscoding agents

• 0:07:46 For a web developer Linux is simply better than the Mac: closer to what you deploy on, with phenomenal tooling and a reproducible setup.

  Linux

• 0:09:46 Basecamp was the best business idea he will ever have: lightning is not caught twice, and a founder's second idea is rarely as good as the first.

  startups

• 0:23:27 Designers should find what the spec should be and build it in HTML and CSS themselves, not make a product manager's spec look pretty.

  CSSdesign

• 0:28:33 Aesthetics is truth: when something is beautiful it is likely to be correct, in code as in mathematics and physics.

  tastemathematicsphysics

• 0:32:33 His opinion of AI never changed; the circumstances and the facts did, when agent harnesses and Opus 4.5 made the tools good enough.

  coding agentsAnthropic

All 21 from this episode, along the running time →

Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again

KBKent BeckMFMartin Fowler

Our page for this episode →Watch on youtube.com ↗

• 6:06 For twenty-five years the senior people had the answers to hand, and what has changed is that at this moment nobody knows the answer to anything.
• 7:11 The job of senior people now is to demonstrate not how to use these tools effectively, but how to figure out how to use them, which is a different set of skills.
• 7:54 Nothing in a fifty-year career has hit the industry with the magnitude of AI; it is a whole size difference from anything before it.
• 8:38 Every earlier wave, the internet included, had to be argued for; AI is the first where nobody has to be persuaded that it matters.
• 11:35 Skepticism about a new technology only works if it is total enough to be turned on itself, which is what forces you to stay curious.
• 11:58 Asking what the smallest experiment is that would settle a claim to your own satisfaction has become a thousand times more valuable in the last year.

All 20 from this episode, along the running time →

Scaling Uber with Thuan Pham (Uber's first CTO)

TPThuan Pham

Our page for this episode →Watch on youtube.com ↗

• 0:11:21 A technology being right is never enough on its own: whether it wins turns on whether the world is ready for it and whether the economics work at that moment.
• 0:16:45 Growth without profit is not yet a company: fast growth only makes a business durable once it has been converted into sustained profit.
• 0:17:41 Today's AI boom will end the way the dot-com boom did — consolidation, a wave of failures and a few genuinely great companies — and customers, not argument, will decide which is which.
• 0:26:48 A career is not built by searching for jobs but by accumulating a reputation slowly, so that when you become available the opportunities come to you.
• 0:36:58 A technical leader should let engineers find the flaw in their own design through leading questions rather than announce it, because a discovered flaw is acted on and a reported one is argued with.

  design

• 0:37:48 The right way to specify a rescue rewrite is a couple of scaling constraints and no new features at all, so that hardware can absorb the growth the team has no time to design for.

  design

All 24 from this episode, along the running time →

Chip Huyen: Building when it feels like there's nothing left to build - The Pragmatic Summit

CHChip Huyen

Our page for this episode →Watch on youtube.com ↗

• 1:41 Because anyone can now rebuild whatever you make, the ordinary incentive to build software has been knocked out from under us.
• 3:38 Anything a person can describe, AI can now produce — software has reached the point image generation reached with style.
• 3:48 Every product put into the world removes the need for imagination, because it becomes something anyone can point AI at and copy.
• 4:46 The reason to keep building is that building is practice at problem-solving, and the supply of problems will never run out.
• 5:28 Problems follow a long tail: AI will keep getting better at the common ones, and the edge cases will never go away.
• 6:58 The problems worth a small builder's time are the ones too small for a big AI company to be motivated to solve.

All 14 from this episode, along the running time →

Nicole Forsgren: Leading high-performing engineering teams in the age of AI - The Pragmatic Summit

NFNicole Forsgren

Our page for this episode →Watch on youtube.com ↗

• 2:18 AI did not create the bottlenecks in software delivery; it threw gas on processes everybody already knew were weak.
• 2:42 AI sped up the part of software work we could see, and it is the delivery systems downstream that are now being overwhelmed.
• 3:17 Review became a worse bottleneck under AI, because companies removed the review automation they had once AI started writing the code.
• 3:51 Release management is human group sense-making, and it does not scale to the volume of change AI now produces.
• 5:22 The processes organisations build to make work uniform are usually the same processes that slow the work down.
• 5:41 Delivery will keep being slow until companies apply AI to the human, business-process half of it, not just to coding.

All 18 from this episode, along the running time →

Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit

Simon Willison

Our page for this episode →Watch on youtube.com ↗

• 4:07 A team can stop reading the code it ships, but only by first working out how its agents are to prove that what they wrote actually works.
• 4:43 Trusting model-written code you have not read became defensible only with Opus 4.5, and only for classes of problem you have already watched a model handle.
• 5:55 Test-driven development matters more with coding agents than it ever did with people, because its real effect is stopping the agent writing more code than the task needs.

  coding agents

• 6:41 Writing code with a coding agent and no tests at all is indefensible, because the old objection to testing — that it is extra work you then have to maintain — no longer applies.
• 7:16 A passing test suite is not evidence that the software works, so an agent must also be made to start the thing and exercise it the way a person would.
• 8:37 A language-agnostic conformance suite is the most powerful thing you can hand a coding agent, because the whole instruction becomes: write code until these tests pass.

All 18 from this episode, along the running time →

From IDEs to AI Agents with Steve Yegge

SYSteve Yegge

Our page for this episode →Watch on youtube.com ↗

• 0:06:38 Deep compiler knowledge is still interesting, but it is no longer useful to a working engineer in any meaningful sense.
• 0:18:08 The engineers laid off in AI's name will mostly not find jobs again, they are the first of many, and nobody has a plan for them.
• 0:18:44 A company must cut half its engineers to pay for the other half's tokens, and that is what the layoffs are actually about.
• 0:19:01 Big companies will lose about half of their engineers, because that is where everybody is setting the dial.
• 0:19:23 Groups of two to thirty people will produce output that rivals what the big companies produce.
• 0:20:17 Being anti-AI in 2026 is like being anti-the-sun: the people who stay that way will have to go live underground.

All 25 from this episode, along the running time →