The Pragmatic Engineer

Gergely Orosz

Software engineering at Big Tech and startups, from the inside. Deepdives with experienced engineers and tech professionals who share their hard-earned lessons, interesting stories and advice they have on building software. Especially relevant for software engineers and engineering leaders: useful for those working in tech. newsletter.pragmaticengineer.com

  1. Scaling Uber with Thuan Pham (Uber’s first CTO)

    1 DAY AGO

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

    Brought to You By: • 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’s email about naming (1:02:03) Org structure changes under (1:06:34) Thuan’s work philosophy  (1:12:23) The “three tours of duty” at Uber (1:15:37) Why Thuan left Uber  (1:17:34) Coupang and Nubank (1:21:59) Faire (1:25:31) How Faire uses AI (1:28:24) AI’s impact on software engineering  (1:31:09) The role of the CTO  (1:35:13) Career advice — The Pragmatic Engineer deepdives relevant for this episode: • How Uber uses AI for development: inside look • The Platform and Program split at Uber • How Uber is measuring engineering productivity • Inside Uber’s move to the cloud • Uber's crazy YOLO app rewrite, from the front seat • How Uber built its observability platform • Developer experience at Uber with Gautam Korlam • Uber’s engineering level changes — 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

    1hr 39min
  2. Building WhatsApp with Jean Lee

    18 MAR

    Building WhatsApp with Jean Lee

    Brought to You By: • 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 a manager (53:29) After Facebook (58:53) AI’s impact on engineering (1:02:34) Jean’s advice to new grads and startups (1:06:45) Empowering employees (1:08:17) Book recommendations — The Pragmatic Engineer deepdives relevant for this episode: • How Meta built Threads • How Big Tech runs tech projects and the curious absence of Scrum • Performance calibrations at tech companies • Software engineers leading projects — 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

    1hr 11min
  3. From IDEs to AI Agents with Steve Yegge

    11 MAR

    From IDEs to AI Agents with Steve Yegge

    Brought to You By: • 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 stand (1:24:47) Adapting to change (1:27:32) Steve’s predictions  — The Pragmatic Engineer deepdives relevant for this episode: • Vibe coding as a software engineer • The full circle of developer productivity with Steve Yegge • AI Tooling for Software Engineers in 2026 • The AI Engineering Stack — 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

    1hr 31min
  4. Building Claude Code with Boris Cherny

    4 MAR

    Building Claude Code with Boris Cherny

    Brought to You By: • 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://penname.co/⁠⁠⁠⁠⁠⁠⁠⁠. For inquiries about sponsoring the podcast, email podcast@pragmaticengineer.com. Get full access to The Pragmatic Engineer at newsletter.pragmaticengineer.com/subscribe

    1hr 37min
  5. Mitchell Hashimoto’s new way of writing code

    25 FEB

    Mitchell Hashimoto’s new way of writing code

    Brought to You By: • 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 hiring practices (1:47:52) Mitchell’s AI adoption journey (1:50:41) Advice to would-be founders (1:52:21) Mitchell’s advising work (1:53:20) What’s changing for software engineers (1:55:03) How Mitchell recharges (1:55:50) Book recommendation — The Pragmatic Engineer deepdives relevant for this episode: • AI Engineering in the real world • The AI Engineering stack • Pressure on commercial open source to make more money – and HashiCorp changing its license • How Linux is built with Greg Kroah-Hartman — 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

    1hr 58min
  6. The programming language after Kotlin – with the creator of Kotlin

    12 FEB

    The programming language after Kotlin – with the creator of Kotlin

    Brought to You By: • 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 deepdives relevant for this episode: • Cross-platform mobile development • How Swift was built – with Chris Lattner, the creator of the language • Building Reddit’s iOS and Android app • Notion: going native on iOS and Android • Is there a drop in native iOS and Android hiring at startups? — 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

    1hr 44min
  7. The third golden age of software engineering – thanks to AI, with Grady Booch

    4 FEB

    The third golden age of software engineering – thanks to AI, with Grady Booch

    Brought to You By: • 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 studying complex systems  (1:13:39) How to thrive during periods of change — The Pragmatic Engineer deepdives relevant for this episode: • When AI writes almost all code, what happens to software engineering?  • Inside a five-year-old startup’s rapid AI makeover • Software architecture with Grady Booch • What is old is new again — 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

    1hr 17min

  8. 28 JAN

    The creator of Clawd: "I ship code I don't read"

    Brought to You By: • 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) Testing and debugging  (1:03:49) Why devs struggle with LLM coding (1:07:20) How PSPDFkit would look if built today  (1:11:10) How planning has changed with AI  (1:21:14) Building Clawdbot (now: Moltbot) (1:34:22) AI’s impact on large companies (1:38:38) “I don’t care about CI” (1:40:01) Peter’s process for new features  (1:44:48) Advice for new grads (1:50:18) Rapid fire round — The Pragmatic Engineer deepdives relevant for this episode: • Inside a five-year-old startup’s rapid AI makeover • When AI writes almost all code, what happens to software engineering? • Why it’s so dramatic that “writing code by hand is dead” • AI Engineering in the real world • The AI Engineering stack — 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

    1hr 54min
See All (57)

About

Software engineering at Big Tech and startups, from the inside. Deepdives with experienced engineers and tech professionals who share their hard-earned lessons, interesting stories and advice they have on building software. Especially relevant for software engineers and engineering leaders: useful for those working in tech. newsletter.pragmaticengineer.com

Information

  • Creator
    Gergely Orosz
  • Years Active
    2024 - 2026
  • Episodes
    57
  • Rating
    Clean
  • Copyright
    © Gergely Orosz
  • Show Website
    The Pragmatic Engineer

You Might Also Like