DiscoverThe Pragmatic Engineer
The Pragmatic Engineer
Claim Ownership

The Pragmatic Engineer

Author: Gergely Orosz

Subscribed: 1,256Played: 29,602
Share

Description

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
84 Episodes
Reverse
Brought to You By:• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.• Entire – The Git forge for agent-human collaboration. Built for the scale and throughput of agentic coding.• WorkOS – everything you need to make your app enterprise-ready.—In this conversation, we step into the world of an AI-pilled CEO to explore how their startup works. This episode might as well be a way of succeeding that contradicts the growing convention that AI spending costs are too high and must be clamped down on. Harjot Gill is founder and CEO of CodeRabbit, an AI code review business, and he shipped over 5,000 pull requests last month, spending on AI at a monthly run rate of $250,000(!) It’s certainly not a conventional approach and Harjot gets into detail about the thinking and reasoning behind it.In this episode of The Pragmatic Engineer Podcast, we talk about his background in building software and founding infra startups for the last 30 years, and how things changed into the era of building software factories at CodeRabbit. We talk about why he believes human code review is dead, and how his team maintains quality while shipping at unprecedented speed.We also get into the rising costs of AI development, why Harjot is convinced that tech startups need more funding than ever, and how AI is changing recruitment and the skills for success.Timestamps00:00 Intro03:17 How Harjot shipped over 5,000 pull requests in a month08:46 Harjot’s path into tech and his first startups12:25 Early conviction around AI and founding CodeRabbit14:40 Switching to AI coding20:35 Software factories explained25:37 What’s replacing human code review38:44 Technical debt and deslopping tests46:05 Evals50:25 Formal methods52:05 AI cost at CodeRabbit54:57 Startup funding in 2026 and the value of AI spend1:08:20 Hiring1:13:03 Work pace, sleep, and burnout1:21:55 Skills for the AI era1:24:30 Book recommendation—The Pragmatic Engineer deepdives relevant for this episode:• Inside OpenAI’s agentic software factory• What is happening with code reviews?• What’s the ROI of software engineers’ spending on AI?• Why Ramp built its own in-house coding agent, Inspect• AI SRE: what is it, how could it change on-call – and does it work?• Context engineering with Dex Horthy• Formal methods with Hillel Wayne • Building Codex with Tibo Sottiaux—Production and marketing by ⁠⁠⁠⁠⁠⁠⁠⁠https://penname.co/⁠⁠⁠⁠⁠⁠⁠⁠. For inquiries about sponsoring the podcast, email [email protected]. Get full access to The Pragmatic Engineer at newsletter.pragmaticengineer.com/subscribe
Brought to You By:• 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 does software engineering look like when generating code becomes cheap, and verifying it becomes the hard part?Today’s guest is Satya Nadella, Microsoft’s CEO, who is one of the very few Big Tech CEOs who started his career as a software engineer (back at Sun Microsystems). He joins me to discuss how building software is changing inside Microsoft, and what these changes mean for engineers.We start with Microsoft’s embrace of open source and the lessons from building VS Code in the open. I also ask how Microsoft went from an early lead with GitHub Copilot to catching up with Cursor and Claude Code, and what this reveals about building products around rapidly improving models.Satya explains what a “software factory” means to him, why specifications and verification are becoming more important, and how teams working on existing products like Windows are adapting. We discuss Microsoft’s voluntary exit offers, the anxiety around AI and engineering careers, and why he cautions against drawing long-term conclusions from the slowdown in junior hiring.We also explore open and local models, why companies need to control their own AI infrastructure, and how to build safeguards around increasingly capable agents. Satya closes with advice for engineers who want to excel through this change, and why he’d like to spend more time building himself.Sidenote: we recorded this episode, in Redmond, a few hours before Microsoft’s day-long Outlook outage started: and so there was no way we could have touched on that topic - but expect for me to follow up on that massive outage in a future The Pragmatic Engineer episode.Timestamps00:00 Intro02:12 Microsoft’s open-source shift04:15 Building VS Code in the open05:55 Copilot, Cursor, and Claude Code09:52 Decision engines12:32 Verifying AI-generated code15:39 The software factory20:45 Bringing AI to existing products24:06 Why adopting AI is different to adopting React26:29 The changing role of software engineers29:25 Microsoft’s voluntary exit offers34:05 AI anxiety and changing roles36:35 Junior hiring42:36 Open models45:39 Owning your AI infrastructure51:21 Building trust in AI agents53:48 Local models and hybrid intelligence56:39 Microsoft’s model strategy59:26 Advice for engineers1:01:21 Closing takeaways—The Pragmatic Engineer deepdives relevant for this episode:• How will AI change operating systems? A deepdive into Windows • A pragmatic guide to LLM evals for devs• What is “loop engineering?”• What is inference engineering? A deepdive• What are Forward Deployed Engineers, and why are they so in demand?• What is happening with code reviews?• Building MCP servers in the real world• Microsoft is dogfooding AI dev tools’ future—Production and marketing by ⁠⁠⁠⁠⁠⁠⁠⁠https://penname.co/⁠⁠⁠⁠⁠⁠⁠⁠. For inquiries about sponsoring the podcast, email [email protected]. Get full access to The Pragmatic Engineer at newsletter.pragmaticengineer.com/subscribe
Brought to You By:• 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.• Entire – The Git forge for agent-human collaboration. Built for the scale and throughput of agentic coding.—What is involved in scaling up large, popular products at places like Slack and GitHub? We get an insider’s view on this from Maude Lemaire, a principal engineer and author of ‘Refactoring at Scale: Regaining Control of Your Codebase.’ She spent nearly eight years at Slack, where she led the backend performance infrastructure team, before joining GitHub to tackle database scaling challenges. Most recently, she worked on improving performance at Cursor – including time to first token.In this episode of The Pragmatic Engineer, Maude and I dig into the challenges of scaling some of the world's largest software products. We explore how Slack handled growing numbers of enterprise customers, how it evolved its approach to load testing, and the lessons Maude learned during nearly eight years of scaling Slack's infrastructure.She also tells us what it was like joining GitHub in 2024 when Copilot was taking off, the challenges of working with GitHub's gigantic Rails monolith, and how Maude uses AI in her work – while keeping judgment calls and decision-making firmly in her own hands.Timestamps00:00 Intro03:15 Early years and path to software engineering07:32 First job at Rent the Runway09:17 The HipChat data leak10:54 Joining Slack and the challenges of scaling26:30 Load testing and thundering herds32:29 Event floods38:30 Evolving load testing at Slack48:38 Joining GitHub in 202456:52 The challenges of the Rails monolith1:02:26 How Maude uses AI1:12:40 Advice for engineers interested in product/platform work—The Pragmatic Engineer deepdives relevant for this episode:• Real-world engineering challenges: building Cursor• Pushing software engineering limits with “napkin math”• What is happening with code reviews?• Why reliability is hard at scale: learnings from infrastructure outages • What is Reliability Engineering? • Migrations Done Well • Shipping to Production • The Platform and Program Split at Uber• The present, past and future of GitHub• Why performant code matters (but gets widely ignored), with Casey Muratori• Designing Data-intensive Applications with Martin Kleppmann—Production and marketing by ⁠⁠⁠⁠⁠⁠⁠⁠https://penname.co/⁠⁠⁠⁠⁠⁠⁠⁠. For inquiries about sponsoring the podcast, email [email protected]. Get full access to The Pragmatic Engineer at newsletter.pragmaticengineer.com/subscribe
Brought to You By:• 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.—An engineer who helped create today’s software engineering curriculum now says to burn down almost all of it. What’s the cause of this contradiction? We find out from the lead author of Software Engineering at Google.Titus Winters spent more than a decade at Google, where he led its readability program and built Abseil, Google’s open-sourced foundational C++ libraries. He is currently a Senior Principal Scientist at Adobe, where he focuses on developer experience and productivity.In this episode of The Pragmatic Engineer podcast, Titus and I discuss how his team tackled a massive refactoring project across Google's 250-million-line C++ codebase, why Google made testing mandatory, and his work on updating the ACM/IEEE undergraduate computer science curriculum guidelines.We also explore why traditional productivity metrics miss some of AI’s biggest benefits, what needs to change in CS education, and how new engineers can stand out.Timestamps00:00 Intro07:01 Getting hired by Google09:48 Finding his niche at Google14:32 Why Google made testing mandatory17:45 Why new engineers fear making mistakes20:40 Abseil: C++ foundations at Google23:09 Google’s massive C++ refactoring30:48 AI for rewrites39:07 Software Engineering at Google: the book43:10 Google’s readability reviews47:18 Why teams still matter52:41 Psychological safety58:17 Layoffs and culture1:02:11 Measuring developer productivity1:11:17 Rethinking CS education1:22:56 What new grads should learn1:32:08 Titus’s ideal software engineering curriculum1:36:27 Advice for breaking into tech1:38:35 Book recommendation—The Pragmatic Engineer deepdives relevant for this episode:• The state of the tech industry in 2026• Inside Google's Engineering Culture• Slow down to speed up when working with AI agents• Measuring developer productivity? A response to McKinsey• How tech companies measure the impact of AI on software development• What is happening with code reviews?• When AI writes almost all code, what happens to software engineering?• Developer productivity with Dr. Nicole Forsgren (creator of DORA, co-creator of SPACE) • Measuring the impact of AI on software engineering – with Laura Tacho—Production and marketing by ⁠⁠⁠⁠⁠⁠⁠⁠https://penname.co/⁠⁠⁠⁠⁠⁠⁠⁠. For inquiries about sponsoring the podcast, email [email protected]. Get full access to The Pragmatic Engineer at newsletter.pragmaticengineer.com/subscribe
Brought to You By:• 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.Timestamps00:00 Intro08:20 Stories from Yahoo!12:47 Digg’s v4 rewrite: the insider story26:02 Will’s path to eng leadership30:03 Uber, Stripe, Carta, and Calm35:11 What does a CTO do?38:09 Will’s role at Imprint42:48 How engineering management has evolved51:08 ZIRP’s impact on tech57:21 Career ladders1:01:03 Eng 1 vs Eng 21:06:58 How software engineering roles are changing1:16:25 Revised rules of engineering leadership1:21:57 The risks of becoming a bureaucrat as an EM1:25:57 How to become a CTO?1:31:33 Middle management vs. line management1:41:36 Will’s writing1:52:13 Book recommendations—The Pragmatic Engineer deepdives relevant for this episode:• The end of ZIRP and what it means for startups and the tech industry• Getting an Engineering Executive Job – an excerpt from Will’s book, The Engineering Executive's Primer• What is a Staff+ Engineer?• Inside Stripe’s engineering culture • Engineering career paths at Big Tech and startups • Staying technical as an engineering manager• Performance calibrations at tech companies• Scaling Uber with Thuan Pham (Uber’s first CTO)• Hypergrowth startups: Uber and CloudKitchens—Production and marketing by ⁠⁠⁠⁠⁠⁠⁠⁠https://penname.co/⁠⁠⁠⁠⁠⁠⁠⁠. For inquiries about sponsoring the podcast, email [email protected]. Get full access to The Pragmatic Engineer at newsletter.pragmaticengineer.com/subscribe
loading
Comments