In a world where code generation has become cheap, what has become hard is verification. In fact, I kind of feel like I got to learn because I've not worked in a team that is mostly now code as output. But the code as output has a particular order of operations. It's not like code as output means everybody's just generating all sorts of random code.
Out of nowhere, 2025, Claude Code. For the first time, I felt that you didn't have an immediate response.
When model jumps happen nonlinearly, the form factor has to change. AI-first product building in that sense is unforgiving. In six months or so, IDE kind of faded away.
I'm asking myself, are there parallels to the open source movement and now the open model?
If you just get past this thing called there's going to be one frontier model to have all of the world's knowledge, right? If you don't buy that, then you have to assume that there should be in some sense as many frontier models as firms in the world, right? Because after all,
What does software engineering mean after code generation becomes very cheap? Today's guest is Satya Nadella, Microsoft CEO, one of the few big tech CEOs who started his career as a software engineer. Today we cover what the term software factory means for Satya and how it looks like today inside of Microsoft. Open models, local models, and the idea of unmetered intelligence. The very real anxiety for us devs around AI, Microsoft voluntary exit offers, and why the junior hiring slowdown might only be temporary, and many more. If you want to understand what Satya thinks it will take to become a standout software dev in this age of AI, and want to understand his thoughtful mental models on how to make sense of all this change, this episode is for you. This episode is presented by Turbopuffer, a ridiculously scalable, fast, and cheap hybrid search engine built on top of object storage used by cutting-edge companies like Anthropic, Linear, Ramp, and many others. Many companies who switch to Turbopuffer are cutting their search bills by 50% or more and getting much faster results. Check it out at turbopuffer.com/pragmatic. Satya, welcome to the podcast.
Thank you so much for having me, Gergely.
Well, it's great to be here because I'm not sure if you know, but I was a Microsofty.
Were you here or where were you?
I was in London, and this is the first time I'm here in headquarters. So, you know, like welcome 12 years back. But I want to rewind back there. I was actually at Microsoft when you became CEO in 2014. And I remember distinctly how Microsoft was still very much embracing closed source. And when you came on, you started to embrace open source. There was Visual Studio Code that was released. Microsoft acquired GitHub and went all in on Git before we used TFS. TypeScript was released as open source. And I just wanted to rewind back. Why did you... People were surprised, my friends outside of Microsoft were surprised, even I was surprised. Why did Microsoft go all in on open source?
Yeah, yeah. I mean, at some level, sometimes these narratives and perceptions get shaped, and it takes a lot to change and what have you. Because if you look at even, I would say, commits even into Linux, even pre me becoming CEO, I think Microsoft had significant contributions and were committed to it. But the thing that I think we really made sure that we understood internally and the world understood is Microsoft is committed to open source, right? Whether it is bringing some of our workloads to Linux like SQL Server or contributing to Linux or open sourcing projects like TypeScript and others. I think we're all part, and you know, obviously our, you know, us as stewards of GitHub put us at the center of it, and we just wanted to make sure that we were able to earn the trust of the open source community by doing right by the community. In fact, it's fascinating. I've always thought about this, which is when you look at companies that have used open source and people who have contributed to open source, if there was a true accounting of it at some point, I think Microsoft would be at the top or if not amongst the top, right? In fact, if you look at some quote unquote, a lot of these other companies that have benefited the most from open source have hardly contributed. It's never, and that is, I think, how you know, and like, hey, you can't complain, but that's how the world rolls, which is it's on narratives versus facts all the time.
Well, it's narratives versus facts. That's true. And again, I think there's that Windows legacy from the '90s that shifts people's, you know, like how they think about it. But what I remember made the biggest impact across the developer community was not really open source. It was Visual Studio Code. Yeah, it was open source, sure, but it was also free. And I was a developer before I used Visual Studio, and it was so good. Visual Studio 2003 is still an amazing piece of software. And somehow you decided Microsoft to bring Visual Studio for free in an open source version to the broader dev community, and boom, 10 or 5 years later, it's everywhere, everyone was using it. Was that intentional?
Yeah, in fact, you know that, you know, Eric Gamma and others who were at that time in that place, really was absolutely, it was intentional, even building with community. In fact, you know, when I look at even product making, it was the first time I also got exposed to what I think now people talk about, you know, building in the open. That was really the first time we all learned what building in the open means, having the community around it and just that feedback cycle. I remember even spending time at that time with Amanda Silver and others learning how that team, even the product manager, what does it mean to be a PM on that team, how they every day looked at the community feedback as a way to build versus, you know, top, you know, like it's not like a, you know, I listen to my vice president, I listen to my community. So there were many, many cultural aspects of building in the open beyond open source that I think were fundamentally transformative. In fact, I would say sometimes I sort of feel like we learned a lot of great lessons there. We should have learned it even more deeply and more broadly.
Speaking of learning more deeply or more broadly, Visual Studio Code was everywhere. GitHub was doing great. And then with Copilot, I mean, I was so surprised. I've been looking back how Microsoft was so early to realizing that AI before ChatGPT 3.5, this was I think the 3.0 Over version or so, Copilot was working like magic and there was no real competition for at least a year until 2023 when Cursor came out. And then Cursor came out, and I still felt that you guys were super smart about VS Code because Cursor was based on VS Code, familiar interface, and you know, GitHub Copilot and Cursor were going side by side, competing with one another, keeping up with one another. And then out of nowhere, 2025, Claude Code. And for myself, for people working at startups, even big tech companies, in six months everyone just forgot about the IDE. And I am still so, so surprised that Microsoft, you guys live and breathe developer DNA, it's in your DNA, and it's always been. How do you think you missed that this sudden shift would come? And for the first time, I felt that you didn't have an immediate response.
Yeah, no, it's a great thing to unpack, right? I think, to your point, being early to it, when we, you know, this is pre-GPT-4, right? So when we even started there, and even just the code completions were magical. That was sort of really what Copilot, you know, if you remember, we worked on IntelliSense forever and we made good progress, and then we said, wow, this thing is working. And quite frankly, there was a lot of skepticism that it would ever work, but it started. And that was even my own belief in scaling laws, quite frankly, was fundamentally reaffirmed, let's say, when I started seeing that. And I thought we did a good job of trying to build that product. One of the keys of building with models is when model jumps happen nonlinearly, the form factor has to change quickly, right? That's the, you know, what is AI-first product building in that sense is unforgiving because you have to basically build everything around a given model and then be ready for the next model to have some emergent capabilities and rewire yourself for that, right? Don't be in love with what you built. So that's why even when agentic coding or task handling started becoming something that one could do, right, it's not just code completions, but you could assign small tasks, that's where Cursor really, you know, they took the IDE, they forked, but they did a good job on really the agent mode. And so we then caught up on the agent mode because that was sort of something that we could do on top of even the OpenAI models. But then the thing that hit us was obviously a great work that Anthropic did with their model, which then truly made the CLI as a form factor, and then you could even just say just complete full handling of, you know, code went from input to output effectively, right? I mean, that I think was the transformation. In six months or so, we went primarily that, to your point about IDEs kind of faded away, and then you really had this new way of thinking about code as input. And that's why if I look at the new IDE, it's more about how do I really input the specs and the markdowns and everything else around the software factory. And so that transformation changes. Interesting enough, it's funny that we're talking about it. Like one of the thoughts I have is with these decision engine models, finally I'm back again to IDE because, you know, an interesting way, it's kind of like functions, right? It's intelligent functions that are embedded inside software. So I think that there could be a rebirth even of an IDE as we think about even embedding intelligence in a more token-efficient way. So I don't say it's a permanent shift over in one way. It's about having multiple form factors now that actually help you with model capability.
I do want to ask you here, you mentioned decision models and how you're excited about them. Both of us recently talked with Ilya in different forums. How has your thinking changed on both decision models, but also on the limits of LLMs specifically for programmatic tasks, for coding, for building software in a reliable way?
Yeah, I think that that's kind of it, right? Which is, look, I think the LLMs are fantastic, and we can talk about like even how, you know, we're engineers. Let's cut to the point where they're not fantastic, right? Right. In the sense of how do you even think about the software factory, and there's an entire thing that we can go into. But what I love about decision engines is it's kind of a new primitive, right? And how Ilya talks about it, and how our own decision engine and others are talking about it, and I like that because, you know, it's kind of like, you know, Excel macros, right? You know what happened to spreadsheets with macros can happen with code with intelligence embedded as a primitive, right? And so I don't know, you build any system, like I think I was looking at an Xbox system that they had built for managing all of the community feedback, right? It's a classic community feedback comes, I make a set of decisions based on it. I don't want to really generate LLM code on it. I just want to be able to make decisions, so it's better to embed this primitive, right? It has a distribution, you can make a call, it's sort of a, it doesn't need to be generated again and again, it's token-efficient. And so I think that this is one of those places where software engineering remains very much alive. It's changing. One of the things I like about Ilya's thing is he wants to make it as boring as databases. In fact, to me, a relational database, I grew up with my, my, my, like the most favorite product in the developer chain other than the compilers and the lex and yacc and what have you was the database because the relational database is a reliable way to be able to store, query your information, just made all kinds of applications possible. And I think decision engines in the era of intelligence will also do the same.
Well, in fact, the databases are the heart. And so we talk about what is the essence of a software company. It's the business logic, right? But when you go deeper, it's often in the database. In fact, so much of the business logic used to be coded in stored transactions, some of these things. So I wonder if it's a good one.
It's like, this is the stored procedure of the intelligence era.
Yeah. So I wonder if there's an analogy or a hope, because I do see that we haven't found the right primitive. Like we know that LLMs can generate code, we can use LLMs to do unreliable stuff, but we still, we're missing these kind of primitives, right?
Yeah, yeah. So I'm very excited about it, and this is, I think, the beginning of how, you know, because one of the other challenges, you know, so let's go to the software factory for a second, right? If you look at even how Copilot is built or even the GitHub Copilot runtime is built today, and you know, I think people have blogged about it, and it's fascinating, right? You know, in a world where code generation has become cheap, what has become hard is verification, right? In fact, one of the things that I feel like, oh my God, I wish, you know, I want to join one of these Mark Russinovich, Scott Hanselman, you know, Perceptorships or whatever they call it, because I kind of feel like I got to learn because I've not worked in a team that is mostly now code as output, right? But the code as output has a particular order of operations. It's not like code as output means everybody's just generating all sorts of random code. Like the way you got to build the verification stuff, how do you take every failure and then build back the test case and make sure you truly verify the test, right? I mean, there's just so much, I would say, new type of tribal knowledge people are building up in managing complex software projects. In fact, it was a nightmare, I think, even in that Rust migration they were having, they had to revert back. And so that is sort of all the, quote, great advantages and some massive disadvantages. So that's why, to your point, having additional primitives like this decision engine, I think, are good.
And you mentioned that as a CEO of this amazing company, you see all of the things happening, right? You oversee, you get information, you would want to go and work on a team if you could.
Oh, absolutely. In fact, you know, my dream next job would be that, right? If I could go back and just be part... In fact, one of the things that's interesting, you know, I was going to send mail to Scott and Mark and say, hey, they're doing an unbelievable job of creating this new program inside of Microsoft called Perceptorship. I think they even have a relationship with Carnegie Mellon or something. And that idea that you can have people who can come in even early in career, because I care a lot about, hey, can you have an early in career person come in, join one of these teams, go up the learning curve? Because I think the learning curve, I remember people used to come to Microsoft for an internship, they would go see, hey, how is, you know, Cutler's code, how do I go look at the Malloc implementation? So what's the new form of that is what I think we have to really discover. And so yes, if we, you know, my hope would be one day I get to do that again.
I'm now understanding why so many CTOs, VP of engineering, SVPs do take step downs to work on small teams to learn how to build with these new tools. Right now, seems all is changing.
I absolutely, I think, yeah, the organizational sort of context of it all is changing. That I think, yeah, if I think about it, I think it's very important. In fact, you know, being a lot more hands-on at a time of great change on many fronts, right? By the way, being close to customers, building in the open, there's so much to learn on all aspects of what makes successful products or successful technology. That, yeah, there's plenty of opportunity.
We've now been throwing around the term software factory for a little bit, so let's actually talk about it. I feel this term is a bit vague, but it's coming around. What does it mean for you?
Yeah. So I'm also still kind of coming to grips with it. So I'm pattern matching in what is teams of people in a software team today do, right? So, you know, I think I'd point your viewers to the blog that Bass wrote. I mean, in fact, there are two nice blogs, right? The Copilot team and the GitHub Copilot team. Both of them have these blogs out. One is what one individual developer was able to do that was on the GitHub side, which is maintain an entire runtime. And I think they also migrated, I forget whether it's from Python, I guess, to Rust.
To Rust. But nevertheless, that's a beautiful case study of what the productivity of a single developer and what does it mean to do that maintenance and so on. Then there is the team, I think it's nine or 12 or whatever number of engineers, it's kind of crazy that that's the total size of that team and the software factory. And they've also done a nice blog, but there's so many things there I love. I mean, this is where, you know, if I could just go join that team and really learn it firsthand versus just reading blogs or talking to Bass and team. But for example, the fundamental transformation as I understand it is, right, one is code has gone from being input to output, great. Then you kind of have to say, okay, that means specification and intent, right? Which was always important, design docs were important, and so alignment. And so that's kind of, yeah, very important now. The other fascinating thing I'm also finding is, and I talked to one sort of early in career person who went in, getting into a code base now is actually much easier because the reason when you're managing a software factory, everything is documented. And so then you can ask it questions.
Patient mentor, onboarding buddy.
Exactly. And so you can have your onboarding onto a codebase is so much easier than you scouring around for tribal knowledge that's in people's heads, if you will. Right. So the other thing is I'm learning a lot about this verification stuff, right? Which is the way you want to do agentic coding is like these little tasks that you give it, make sure that it's truly done. How do you have the critique? Right? There's so much to be said about having a separate model family. In fact, that's the other thing that I've always worried about. It's like, hey, if there's one model family and these model families are going to have all these alignment issues, how do you use a critique to ensure that one model family's challenge doesn't become your challenge? And so anyway, I kind of look at, say, there's an entire new way to build that is emerging, and it's new software engineering, and it requires software engineers. It's just a level of interaction, maybe that's why I like even the analogy of, you know, when you went from writing your own assembly to saying, oh wow, I have a compiler, and suddenly you felt like, oh wow, I can now go from intent to code, and I don't need to know assembly. There's a little bit of that, it's a level of abstraction, but even how you work in a team has changed, and how you construct a product has changed. The other one that I'm really excited about is the traces from production coming back.
I love that too, right? Which is, you know, we're talking observability, but you have more opportunities.
Yeah. I mean, when people say like, you know, RSI, that's kind of my RSI, right? Which is it's sort of the ability to take my production logs and then to be able to verify the fix. In fact, that verifiability loop is great that you can then deploy the fix and deploy it all the way through that it actually passed all the tests. That actually is very helpful. And so I think there's a lot of learning that these teams are having, and it's spreading across Microsoft. I mean, it's just good to see how this is now becoming the way teams are structuring. The other one that I love is our networking, Azure networking team, right? In fact, that used to be my favorite story where this team said, hey, Microsoft manages something like 500 fiber operators all over the world for our global network. And you know, always it's a physical asset, something or the other goes wrong. You know, the fancy word for managing all that is DevOps, but the reality is it's emails and, you know, all sorts of ad hoc processes. And so they went and built this entire agentic system that actually does the ops, and that ops is connected even to their repos. And so now it's not just the repo on its own or the codebase, but it's even the operations that are around it. And so you can start seeing how the nature of what technical teams do is build these factories of ops plus software that do the job versus doing the job. But still they're doing a job which is slightly different.
I do wonder because at AI labs, it's pretty common, and they're very open about sharing how software engineers there, their job is becoming to allow the agent and the loop to do a better job. So what you just said, but just sticking to practical level, like at a place like Microsoft, you will have teams that can experiment and they're building new factories or their platform teams, and maybe they have extra cycles and they're doing all these things, but you also have product teams who actually have a product, you have real customers. And this is where I see a lot of companies struggle with who do have a real business and they're seeing these aspirational things from AI labs, or maybe even they're listening to you right now and they're thinking, hang on, like I can't just drop everything and build a factory because what am I going to do with the thing? How are you thinking about both this balance, and especially inside of Microsoft, what do you tell engineers? Like how is your job changing, especially when you're working on a product that is a good product, it's a profitable product, customers depend on it?
Yeah, it's a great point. I mean, like, first of all, you know, we don't get permission to do things that are not adding value to customers. Like, let's start there, to your point about a little bit of, and we made our share of mistakes of, you know, going and doing random AI things just because they were, you know, cool to do. You kind of ultimately are going to...
I think everyone's done that.
Everyone's done that, and I've done my fair share of it and learned from it hopefully, and we'll get better. But that said, if you sort of say, well, let's take even, let's face it, right, which is today when I look at the CVE in Windows, right? Because you now have AI models that are finding vulnerabilities.
And so we now need to go fix them all. And so therefore, there's a new pipeline. So in fact, if I look at even the Windows from crash traces all the way to fixes, they're building out essentially a new type of software factory, except this is a brownfield, right? Which is the build system of Windows still is still the build system of Windows. In fact, if you think about in all these brownfield projects, the most difficult part is builds and CI/CD. And then of course you got to really, you know, even, you know, if I look at the amount of change that underneath even GitHub, right, which is if you think about it, right, you know, we've had, I mean, suddenly all these coding agents showed up to work at GitHub and the scale has gone through the roof.
Yeah. And so therefore we have to fundamentally change the entire Git protocol, the storage system. We are working on every part of this to make sure that we are living in the brownfield as opposed to, I mean, the greenfield stuff we'll always do, but the real world is all about brownfield, and the brownfield requires stepwise, you know, hardening of systems, rethinking of the core primitives, right, all the way from source code control to build to CI/CD that works in a brownfield project. And that takes time, that takes investment, that takes thought, and the sequence of operations or the order of operations is very, very critical. So one of the things that I want our teams is not about, well, one nice thing I like about the transformation is this is not about, oh, here is some new shiny object and here is the team that's doing that and everybody else lives in the old world. Like everybody across the company gets to use the new toolchain and the new ways of working and tackle the challenge in front of them on any product, whether it's Windows or SQL Server or a cloud-native service, what have you. And that I think is what we're seeing.
To be fair, like this doesn't sound all that different to what we did in the past because when there was a new technology, let's say React, which was a new front-end technology, everyone wanted to use it. And what we did is no one got permission to just stop and migrate to React. But when you built a new product or you added a new feature, you start to add it in, you start to mix it. So maybe it's not all that different to how we're adopting AI. But what is different about this? Is it?
It's a good one. Like, you know, sometimes I, you know, I kind of say, yeah, I've seen this before and what have you. But I think the one thing that I do feel that's different this time around is that the physics of how we do things, right, that order of operations, the level of abstraction, maybe. In fact, one of the fascinating things I think about is it is like when people moved, right, I joined the workforce at the cusp of when we went from, you know, in fact, in college I was mostly working on a VAX, right, you know, with a VT, you know, terminal.
Yeah, or a mini, mini, right, VMS systems, right? So, and then I joined actually for a couple of years at Sun on a workstation, and then I came to Microsoft. And so, and then, you know, the world kind of was stable, right? You mostly wrote code in an IDE throughout my professional career. It sort of didn't really change. I mean, new technologies came, but all those new technologies were new frameworks and new runtimes. It was not like the concept count radically changed. Even the mobile thing was sort of a miniaturized PC with new sort of user interface, right, and new frameworks. This is a place where everything, what is the runtime, what is the framework, what is the IDE, what's the stack.
You're right, every single part.
It's a little more of a change in how you think about, I think, then let's not forget a new model could drop, right? Whether it is a new frontier model or a new thing like decision engine, and it could change again, right? This is where I think we also have to be ready for the regime to completely be transformed at any moment, if you will. And so therefore, I think these are two things at least I think about, that thinking of it, learning from the past when we were at our best individually or as companies or as teams in managing change, I think is always important, but also being open-minded that this time is different is also good.
Yeah. And also specifically for the biggest change for us software engineers, and you know, Microsoft has probably majority of the workforce is software engineers or people close to the code, is we used to spend most of our time writing code, and most of our effort was learning at college, at previous jobs to be good at this, and this part suddenly disappeared, which I know for a lot of people, including me for earlier, it was hard to reconcile because we've never seen it with any technology change. It always added a new tool. How do you see people inside of Microsoft or outside who you talk with reconcile this, who are really good engineers and they've spent decades getting very good at coding, which is hard to do, right?
Yeah, no, I think that that's right. I think so this is where what at least I am observing, and as I talk to even people who are, you know, both been great software engineers previously and now are prolific even in the new mode of production, is the same skills are still required. It's just again that what you think about the order of operations, the toolchain has changed. And so that's one of the other reasons where I don't think it's about devaluing the expertise. It's about really taking the expertise and making sure that you can exercise that with new leverage, right? That is where the nature of how you work has to change as opposed to thinking that this is about software engineering no longer being important. And I think that we're in that phase, right, where we are trying to figure out how to value the new thing, and in valuing the new thing, you are suddenly going to even start valuing the old thing if it makes sense, right? Which is when I look at the people, there's obviously somebody who is AI-native who comes out of, like, in fact, it is funny, last GitHub Universe, I went down and I met a bunch of college kids, and that was the first batch of college graduates who grew up in the AI era, right? Because they went to college...
...when GitHub Copilot...
Right, so they didn't know an IDE world pre-GitHub Copilot. It was like stunning to me that that was sort of what's happening. So there's going to be people who are going to come at this who are going to be native to this toolchain, but I also think that people, when I see at Microsoft, anyone who has great depth and expertise in any part, has curiosity, and is sort of learning the new ways to work, are absolutely flourishing in it. And so one of the things I'm hoping to ensure is we create that opportunity for folks, because at the end of the day, right, you know, it's about economic return on your professional careers that matters. And so therefore, we want to make sure at Microsoft you can both value the skill set you have and build the new skill set that the marketplace will value.
I'm really liking how you're looking at this, and also how you talked about how junior, new grads, early career people are contributing, they can get up to speed. But one thing that's been going around in dev circles, and I'll just lay it out for you, is people are speculating, why is it that Microsoft is making the voluntary retirement offers? Like, what does this mean? There's this fear that could this be a prelude to potentially a layoff because of AI making teams more efficient? And I just wanted to ask you dead on the head, there's never been anything like this at Microsoft, which is what I actually paid most attention to, and also the fact that it is voluntary. How did your thinking and the company's thinking come together on this one?
It's a very important question, and you know, one of the things that we discussed a lot, and we felt was let's acknowledge two things, right? One is that, or maybe three things. One is that let's acknowledge that there is going to be plenty of opportunity going forward. The shape of that opportunity may be different than what is the opportunity, right? If you let's even narrowly think about just software engineering as we were discussing.