AI Trends

Nadella Responds to Microsoft's First-Ever Buyout Offer: Claude Code Eroded IDE Advantage in Six Months

36Kr · AIUpdated Nov 17 22:05

AI summary

On The Pragmatic Engineer podcast, Microsoft CEO Satya Nadella responded to Microsoft's voluntary severance program launched on October 26, acknowledging that Anthropic's model progress has made the CLI a viable product form, with the IDE fading from view in about six months, and said future team sizes, workflows, and staffing will all be different. He proposed a software factory approach: once code shifts from input to output, specifications, intent, and verification matter more, with humans handling specs and verification while agents carry out execution. He also argued that enterprises must control their own learning loop, keeping context, memory, harness, and models separate from one another, and continue using OpenAI models through partnership while building the MAI model family from scratch.

Why read this

SelectedAI score 81

Nadella recounts how Claude Code shook the IDE's advantage and shares his views on software factories and building in-house AI infrastructure.

Topics

Tags

Body · AI translation

Microsoft once taught developers around the world how to write code; now it is paying some of its own engineers to leave.

On October 26, Microsoft announced a new voluntary severance program. On November 16, on The Pragmatic Engineer podcast, host Gergely Orosz posed a pointed question to Microsoft CEO Satya Nadella: why now? Could this be a prelude to further layoffs after AI improves efficiency? Behind this question lies a technological shift that caught Microsoft off guard.

Claude Code, a product that had been on the market for only a few months, unexpectedly began to challenge development tools that had accumulated more than twenty years of experience.

"I'm 99% sure that Anthropic knows nothing about any Microsoft strategy, and they don't care at all. They completely ignored all existing technology and built a very good tool," Gergely remarked. He believes the impact of this on Microsoft will far exceed anything else. "Not just Microsoft—JetBrains was likewise caught off guard, likewise unprepared."

For more than two decades, the IDE has been almost always at the center of software development. Microsoft owns Visual Studio, VS Code, and GitHub, and it was first into the AI coding market with GitHub Copilot. Even when Cursor appeared, the competition still took place within the editor ecosystem Microsoft was familiar with. This was once a seemingly unshakable advantage.

When Gergely recently reviewed Microsoft's VS Code strategy on X, he summed it up in three words: "Embrace, Extend, Extinguish." Microsoft spent more than a decade building an almost foolproof path: make VS Code good enough, open-source it, let developers freely build products on top of it, yet make it very difficult to surpass Microsoft in the competition over development tools themselves.

The emergence of Claude Code changed the way competition works. Nadella also acknowledged that Anthropic's major progress in model capabilities dealt a blow to Microsoft. In just about six months, the IDE had to some extent "faded from view."

The stall on the product side is happening at the same time as organizational restructuring. Faced with the question of voluntary severance, Nadella did not promise that everything would stay the same. He made clear that future team sizes, workflows, and staffing would all be different, and that Microsoft's 200,000 employees would need to reorganize in new ways. "Of course I wish I could tell everyone that everything will be the same as before, but I can't."

The changes are also affecting Microsoft's talent needs. Nadella revealed that as for the slowdown in hiring junior engineers, it is too early to conclude that this trend will persist long term. Companies need to first build new "software factories" and rearrange people and token resources before they can decide what kind of engineers they will need in the future.

This interview therefore raises a sharper question than "how much code can AI write": when code becomes ever cheaper, how much longer can the tool advantages, organizational experience, and the abilities engineers rely on to earn rewards—accumulated by Microsoft over decades—still be priced the way they used to be? Nadella's direction is the "software factory": humans handle specifications, intent, and verification, while Agents take on more and more execution. For a company that built a vast empire on software engineering, this means it must personally transform its own mode of production, and must also decide anew what kind of engineers are worth continuing to invest in and what kind of work needs to be rearranged.

After the interview ended, Gergely made a more direct judgment about Microsoft's coming changes: "There will be a lot more organizational adjustment inside Microsoft; teams will get smaller, roles will change. The voluntary severance program offers an exit for those who don't want to go through this round of change. The changes ahead are likely to be denser and more drastic than before. I think this kind of organizational restructuring, role changes, and stronger pressure to transform than in the past will also appear in many other tech companies."

As for what companies should hold on to amid the AI wave, his summary is equally sharp: "For a company, if it doesn't control its own AI infrastructure and AI intellectual property, that is in fact a self-destructive strategy. Satya believes that every successful company will build its own AI infrastructure, and that companies relying on a single vendor or a single AI lab are making a major strategic mistake."

TL;DR:

Gergely Orosz: Microsoft launched GitHub Copilot early on, then Cursor appeared, and the two sides kept competing. But the rise of Claude Code in 2025 led developers to begin moving away from IDE usage in just six months. Why did Microsoft, with its deep developer DNA, not respond to this change right away?

Satya Nadella: When model capabilities make a nonlinear leap, the product form must change quickly. This is the very cruel part of AI-first product development. You cannot become infatuated with the product you have already built. Cursor did a great job on Agent mode, and then Anthropic's model progress made the CLI a viable product form, and developers began handing complete tasks to the model. However, I do not think the IDE will disappear forever. With the emergence of new capabilities such as decision engines, the IDE may even see a revival.

Gergely Orosz: You have mentioned the "software factory" many times. If code is mainly generated by AI, what exactly does this new way of software development mean?

Satya Nadella: In a world where the cost of code generation has become very low, the truly difficult thing has become verification. Code has changed from input to output, so specifications, development intent, and verification mechanisms have therefore become more important. Engineers need to hand tasks to Agents, check whether the tasks are truly completed, and build test cases based on failures. They can also use production environment logs to discover problems, verify fix results, and then deploy the fixes to production. This is still software engineering; it is just that the level at which engineers interact with code has changed.

Gergely Orosz: After Microsoft launched a voluntary departure program, some developers worried about whether this means the company will further lay off employees after AI improves team efficiency. Why did Microsoft make this decision?

Satya Nadella: There will still be plenty of opportunities in the future, but the shape of those opportunities will change, including team size, workflows, and role allocation. Launching the voluntary departure program is largely about giving employees more autonomy to choose, and to find the position that suits them based on their long-term career development. I cannot say that every division at Microsoft is transforming at the same pace. If employees feel trapped in a team that has not kept up with the changes, they should be able to choose other opportunities, including roles within Microsoft. I hope the company can create these opportunities, but I cannot guarantee that everything will be the same as in the past.

Gergely Orosz: Many companies have slowed or even stopped hiring new graduates, because experienced engineers seem better able to use AI to improve productivity. How does Microsoft view the hiring of young engineers?

Satya Nadella: I think it is too early to regard the current slowdown in hiring as a long-term trend. Companies first need to adjust their internal staffing and ways of working, build new software factories, and only then decide what kind of talent to bring in. An AI-native company may start with one employee and a certain Token budget, and when that employee uses up the budget, add the next employee and their Token budget. More teams may adopt a similar approach in the future, but completing organizational restructuring takes time, so hiring changes should be observed over a longer time span.

Gergely Orosz: Many companies are building their own Harness, context layer, and inference infrastructure. Do you think most enterprises should own these systems and make each component independently replaceable?

Satya Nadella: Exactly. Enterprises must control their own learning loop and must not leak their most valuable knowledge in the process of using AI. Context, memory, Harness, and models should be separated from one another; otherwise, they may become completely locked in by a certain vendor. My test is simple: you should be able to replace any model while still continuously improving on your own private evaluation metrics. If you cannot do that, you must ask yourself whether you can still independently control your enterprise's output.

Gergely Orosz: Enterprises are building a large number of new AI systems, but many of them do not yet have mature architectural blueprints. How do you think enterprises should address reliability and security issues in them?

Satya Nadella: I think enterprises must establish a trust architecture. Scaling laws have brought stronger model capabilities, but that does not mean the alignment of models has improved in tandem. We must separate intelligence from permissions at the architectural level. If an insufficiently reliable Agent also has execution permissions, it may bring serious internal risks. Therefore, Agents need to be managed as potential internal risks, with monitoring, observability, audit logs, and security protection mechanisms established at runtime, and enterprises must always be able to control their own learning loop.

Gergely Orosz: Microsoft is trying to let closed-source models run directly on laptops. At the same time, you are also independently developing MAI models. How does Microsoft plan to choose and use these models in the future?

Satya Nadella: We will continue to use OpenAI's models through cooperation, while also building our own MAI model family from scratch. What we focus on is not only model capability, but also FLOPs efficiency during training and Token efficiency during deployment. In the future, a task may be completed by multiple sub-Agents, and different sub-Agents may use different model families, or combine local and cloud models. Our goal is to let the system automatically choose the most suitable model based on the task, rather than always being tied to one model family.

Gergely Orosz: If a software engineer wants to become a truly excellent engineer in the AI era within the next year or two, what advice would you give them?

Satya Nadella: Talk a little less, do a little more, learn a little more, and really get hands-on with these new technologies. Don't just follow the headlines or chase round after round of hype. Even for myself, if I could change the ratio of time I spend discussing versus actually doing, I would want to do that. Whether you're a senior engineer, a CEO, or a fresh college graduate, you should spend as much time as possible learning and practicing, and join teams that are genuinely using new technologies to do real work. The times when I'm at my best are often when I'm in a student state of mind. So let's go back to school.

From Open Source to VS Code: How Microsoft Changed the Way Software Is Built

Host Gergely Orosz: When you became Microsoft CEO in 2014, I was actually still working at Microsoft. I clearly remember that at the time, Microsoft was still very committed to the closed-source model. But after you took over, Microsoft began actively embracing open source. Later, Visual Studio Code was released, Microsoft acquired GitHub and fully switched to Git, whereas we had previously used TFS. TypeScript was also released as open source.

I want to go back to that point in time and ask why you made that decision. Many people were surprised at the time—my friends who didn't work at Microsoft were surprised, and even I was surprised. Why did Microsoft decide to fully embrace open source?

Satya Nadella: I think, in a way, once people form a perception and judgment of a company, it's very hard to change. But if you look back at Microsoft's past work, you'll see that even before I became CEO, Microsoft had already submitted a large amount of code to Linux and continued to invest in related work. I think we had already made fairly significant contributions at that point.

However, I think one thing we really worked hard to achieve was making it clear both inside Microsoft and to the outside world that Microsoft firmly supports open source. Whether it was bringing Microsoft's own workloads like SQL Server to Linux, contributing code directly to Linux, or open-sourcing projects like TypeScript, these were all ways we participated in the open source ecosystem.

Of course, Microsoft's role as the steward of GitHub also puts us at the center of the open source ecosystem. We want to earn the open source community's trust through actions that genuinely benefit the community.

In fact, this is interesting—I've been thinking about a question: if we carefully counted how much open source software companies use and how much they each contribute back to the open source community, I think Microsoft would very likely be at the top—if not first, then certainly one of the largest contributors. When you look at some other so-called tech companies, you'll find that many of those that benefit the most from open source contribute almost nothing. But people never seem to see them that way. Of course, there's no point complaining—that's just how the world works. Often, people believe the popular narrative rather than the facts.

Gergely Orosz: Right, this is indeed the gap between narrative and fact. I think the Windows-era image Microsoft formed in the 1990s still influences how people see the company today. But in my impression, what really had the biggest impact on the developer community wasn't entirely open source—it was Visual Studio Code.

VS Code is open source and also free. I'm a developer myself, and I used to use Visual Studio, which is excellent software. Even Visual Studio 2003, looking at it today, is still a great product. But Microsoft later decided to offer Visual Studio as a free, open source version to the broader developer community. As a result, five or ten years later, VS Code is almost everywhere—everyone uses it. Was this something you deliberately pushed for?

Satya Nadella: Yes, it was entirely deliberate. At the time, Erich Gamma and the others involved in the project thought about it this way, and from the very beginning they placed great importance on building the product together with the community.

In fact, when I look back on my product development experience, I find that was also my first real exposure to what people today often call "Building in the Open." It was the first time we truly understood what it means to build a product in an open way: letting the community participate and establishing a continuous feedback loop around the community.

I remember I also spent quite a bit of time talking with Amanda Silver and others to understand how that team worked. I especially wanted to know what being a product manager actually meant on such a team, and how they used community feedback every day to drive product development. Their way of working was no longer about following instructions from management top-down—not "I listen to the vice president," but "I listen to the community."

So I think the changes brought by open development go far beyond open source itself. It also involves many cultural-level changes, and these changes fundamentally transformed how we develop products. Sometimes I even feel that we learned a great deal of very valuable experience from it at the time, but we should have understood that experience more thoroughly and spread it to a broader range of organizations and businesses.

Claude Code caught Microsoft off guard, and Nadella believes the IDE may see a revival

Gergely Orosz: Speaking of deeper and broader learning, at that time Visual Studio Code was already ubiquitous, and GitHub was also developing very well. Then Copilot appeared. I have always found it incredible that Microsoft recognized the potential of AI in programming so early. That was before ChatGPT and GPT-3.5 appeared; I remember what was being used at the time should have been some version of GPT-3. Copilot's performance was simply like magic.

For at least the following year, Copilot had almost no real competitor, until Cursor appeared in 2023. Even so, I still think Microsoft's positioning on VS Code was very smart, because Cursor was built on VS Code, and developers were very familiar with its interface. GitHub Copilot and Cursor began to run neck and neck, competing with each other and constantly catching up with each other.

But by 2025, Claude Code suddenly appeared. For myself, and for developers working at startups or even large tech companies, in just about six months, everyone seemed to have left the IDE behind. This still surprises me very much to this day. Microsoft has always been a company with a deep developer DNA; developer culture can be said to have long been embedded in your DNA.

So I am very curious: why do you think Microsoft failed to foresee this sudden shift? This is also the first time I have felt that, in the face of a major change in how development is done, Microsoft did not immediately come up with a response.

Satya Nadella: This is a question very worth discussing in depth. As you said, we did indeed start exploring AI programming very early. At that time GPT-4 did not even exist yet, and we had already begun advancing related work. Even with just code completion, the effect at that time was already incredible. If you remember, the original Copilot was mainly doing this.

Before that, we had already invested many years in developing IntelliSense and had made good progress. But when we saw AI code completion truly working, we were still very shocked. Frankly speaking, many people at the time doubted whether this technology could succeed at all. And when I saw with my own eyes that it began to work, my own confidence in Scaling Laws was fundamentally strengthened.

I think we did a good job in product development at the time. But building products based on models has a very critical characteristic: when model capabilities undergo nonlinear leaps, the product form must change quickly.

In this sense, developing a truly AI-first product is very brutal. You must build the entire product around the capabilities of the current model, while also being ready at all times for new capabilities that the next model may emerge with, and readjust the product architecture accordingly. You cannot be too attached to what you have already built.

So when Agents began to have programming and task-handling capabilities, the situation changed. It was no longer just completing code, but could accept and complete some small tasks. Cursor did exceptionally well precisely at this stage. They forked development based on the IDE and put a great deal of effort into Agent mode, achieving very good results.

Subsequently, we also caught up in Agent mode, because even based on OpenAI's models, we could likewise achieve these capabilities. But what really hit us next was the major progress Anthropic made on models. Their model capabilities made the command-line interface (CLI) truly become a viable product form. Developers could even directly hand complete programming tasks to the model and let it handle the entire process from input to output. I think this was the fundamental change that happened in those six months. As you just mentioned, the IDE gradually faded out of people's view to some extent, replaced by a completely new way of thinking: how to take code and its related requirements as input and hand the follow-up work to AI.

Therefore, if I were to rethink the form of the IDE, I would focus more on how to input specifications (Specs), Markdown documents, and other information needed to operate around a "Software Factory." The entire way of development has changed because of this.

However, interestingly, as we discuss this topic now, I have begun to have another thought. With the emergence of these Decision Engine Models, I find that I seem to have returned to the IDE again.

From a certain perspective, these models are somewhat like functions, except that they are intelligent functions embedded within software. Therefore, when we begin to think about how to embed intelligence into software with greater token efficiency, the IDE may experience a revival. So I don't think the way we develop has undergone some permanent, irreversible shift. More precisely, we now need multiple different product forms, each adapted to and able to leverage the different capabilities of models.

Gergely Orosz: You just mentioned decision models, and also talked about why you are excited about this technology. We have both recently spoken with Diego on different occasions. I'm curious, what changes have occurred in your view of decision models now? At the same time, how do you view the limitations of large language models (LLMs), especially in procedural tasks, programming, and reliably building software?

Satya Nadella: I think this is exactly the crux of the matter. LLMs are indeed excellent, but since we are both engineers, we might as well discuss directly where they do not perform well enough. For example, when we think about how to build a software factory, we encounter many issues worth discussing in depth. And what attracts me most about the decision engine is that it provides a new kind of primitive. Diego, as well as our own decision engine team, are discussing this technology from this angle.

This reminds me of Excel macros. The changes that macros brought to spreadsheets back then may now also happen in the field of software development, except that this time, we can embed intelligence into code as a kind of primitive. For example, I recently saw that the Xbox team built a system to manage community feedback. This is a very typical scenario: the system receives community feedback and then makes a series of decisions based on that feedback. In this process, I don't need to have the LLM continuously generate code; I just want the system to make decisions. Therefore, a better approach is to embed this decision-making capability directly into the system as a primitive that can be called. This kind of primitive has its own probability distribution, can be called directly, does not need to be regenerated every time, and is more token-efficient. I think this precisely shows that software engineering still has very important value, except that it is changing.

I really like an idea proposed by Diego: he wants to make decision engines as commonplace as databases. In fact, for me, relational databases have always been a very important technology. When I first started in software development, apart from tools like compilers, Lex, and Yacc, my favorite development tool was the database.

Because relational databases provide a reliable way to store and query information, making all kinds of applications possible. I think that in the age of intelligence, decision engines will play a similar role.

Gergely Orosz: Actually, the database is the truly difficult part. We often discuss what the core of a software company really is. The answer is usually business logic. But if you dig deeper, you will find that a lot of business logic actually resides in the database. In the past, a large amount of business logic was implemented through mechanisms such as stored procedures and transactions.

Satya Nadella: That analogy is interesting. Decision engines may be the stored procedures of the intelligence age.

Gergely Orosz: Exactly. So I am wondering, does this represent a development direction worth looking forward to? Because I do feel that we have not yet found the right primitive. We know that LLMs can generate code, and can also be used for tasks where the results are not so reliable, but we still lack this kind of primitive that can be reliably embedded into systems.

Satya Nadella: Yes, so I am very excited about this technology.

Code generation is becoming cheaper, and software engineers are beginning to build "software factories"

Satya Nadella: I think this may be a starting point for us to reunderstand the way software is developed. Because there is another very important challenge. Let us return to the topic of software factories and look at how Claude Cowork or GitHub Copilot Runtime is built today. The relevant teams have published some blog posts, and the content is very interesting.

In a world where the cost of code generation has become very low, the truly difficult thing has become verification. In fact, sometimes I especially wish I could join some apprenticeship program promoted by Mark Russinovich and Scott Hanselman, whatever they eventually call it. Because I feel I still have a lot to learn. I have not yet truly joined a team where code is mainly generated by AI and the focus of team members' work has shifted to managing this code output.

But even if code has become output, the entire workflow still needs to follow a specific sequence of operations. This does not mean that everyone can casually generate all kinds of code. You must first establish the corresponding verification mechanisms. Whenever a failure occurs, how should test cases be built based on the failure? And how can you ensure that the tests themselves can truly verify the problem?

I think that in the process of managing complex software projects, developers are accumulating a great deal of new practical experience, much of which is tacit knowledge that has not been formally documented. In fact, I remember one Rust migration ran into very thorny problems, and the team ultimately had to roll back.

So this way of developing brings both enormous advantages and fairly obvious drawbacks. That is exactly why I think we need additional foundational components like a decision engine.

Gergely Orosz: You just mentioned that you would like to join such a team to learn. That interests me a lot. As the CEO of such a large company, you can see all kinds of changes happening inside the company, learn about how various teams work, and also get a great deal of information. But if you had the chance, you would still want to personally join a team and work, right?

Satya Nadella: Of course. In fact, if I were to choose my next ideal job, I would really like to go back to such a team.

I have even thought about sending an email to Scott and Mark. They are creating a very impressive new development program inside Microsoft, I think it is called Preceptorship, and it seems to have some kind of partnership with Carnegie Mellon University. I really like the idea behind this program, because I have always cared about how engineers grow early in their careers. Can we let a young person who has just entered the industry join such a team and help them gradually master the new way of developing? I think this is a very important question.

I remember that in the past, many people who came to Microsoft as interns would study the code written by Dave Cutler, or find some way to see how an important module was implemented. By reading code written by these excellent engineers, they could learn a great deal. So in today's new development environment, what is the corresponding way to learn? This is a question I think we must seriously explore. So I do hope that one day I can regain such an opportunity and personally join a team to learn.

Gergely Orosz: Now I am starting to understand why so many CTOs, VPs of Engineering, and even senior vice presidents are willing to give up their original management positions and join smaller teams. They want to personally learn how to build software using these new tools, because almost everything is changing right now.

Satya Nadella: Exactly. I think the environment in which the entire organization operates is changing. In a period when every aspect is undergoing major transformation, it is very important to be more deeply involved in the actual work. Not only the technology itself, but also staying close to customers and building products in an open way, there is a great deal to learn in all these areas. Whether it is how to build successful products or how to develop successful technology, we have many opportunities to relearn and explore.

Gergely Orosz: We have mentioned the term "software factory" several times already, so we might as well discuss it formally now. I feel this concept is still somewhat vague at the moment, but it is being mentioned more and more. What does a software factory actually mean to you?

Satya Nadella: Actually, I am still trying to understand this concept myself. Right now I am mainly observing how different teams work, looking for the common patterns gradually forming among them, and seeing what today's software teams are actually doing.

I suggest the audience read the blog written by Bass. In fact, there are two articles worth reading, one from the Cowork team and the other from the GitHub Copilot team. Both articles show very interesting practices.

The GitHub case is about a single developer being able to maintain the entire Runtime alone. They also seem to have completed a language migration, I cannot quite remember whether it was from Python to Rust. Anyway, in the end it always has to migrate to Rust. But in any case, this is a very good case showing what level of productivity a single developer can achieve, and what happens to software maintenance work in that situation.

The other case comes from the Cowork team. I remember the whole team had only 9 or 12 engineers, I cannot remember the exact number, but the team size was indeed astonishingly small. They built their own way of developing around the software factory and also published a very good blog post.

There is so much in these two cases that interests me. If I could, I really wish I could directly join that team and personally understand how they work, rather than just reading blogs or talking with Bass and team members.

As I understand it, the most fundamental change in this way of developing is that code has gone from input to output. In the past, the main job of engineers was to write code; now code itself has become the result generated by the system. This means that specifications and development intent have become more important. Of course, design documents were also important in the past, and team members also needed to reach consensus, but now the importance of these things has increased further.

One other thing I find interesting. I recently spoke with an engineer who is just starting out in his career, and he told me that understanding an unfamiliar codebase has actually become much easier now. The reason is that when you manage development work the software factory way, everything gets recorded and turned into documentation. As a result, you can ask questions directly about the codebase.

Gergely Orosz: Like having a very patient mentor, or a buddy who helps newcomers get oriented.

Satya Nadella: Exactly. That makes it much easier for newcomers to get familiar with the codebase, and they no longer have to go hunting around for the tacit knowledge that exists only in the heads of longtime employees.

Another area where I have learned a lot is verification. When programming with Agents, you need to break the work into small tasks, hand them to the Agent to execute, and then make sure each task is actually completed. But how exactly should review and evaluation be done? There are still many questions worth studying behind this.

For example, should different model families be used for review? This is actually something I have been very worried about all along. If we rely only on the same model family, and that model family itself has certain alignment problems, then those problems could pass directly into the software we build.

How can we use independent review mechanisms to ensure that the flaws of a particular model family do not become our problems? This is a very important challenge. So I think a whole new way of developing software is taking shape. It is still software engineering, and software engineers are still needed; it is just that the level at which engineers interact with code has changed.

That is also why I like to use the evolution of compilers as an analogy. In the past, programmers had to write assembly code themselves. Then compilers came along, and suddenly everyone found they could translate their intent directly into code without having to deal with assembly language themselves. What is happening now is somewhat similar to what happened then; in essence, both are a raising of the level of abstraction. But this time, what is changing is not only the way code is written, but also how teams collaborate and how products are built.

Another direction that excites me especially is feeding execution traces from production environments back into the development process. I really like this idea.

Gergely Orosz: We have been talking about observability, but now we can use this data to do much more.

Satya Nadella: Yes. People often talk about recursive self-improvement (RSI), and in a way this is what I understand RSI to be. Specifically, it means using logs from production environments to find problems and then verify the fixes. This verification loop is very important: you can generate a fix based on actual runtime conditions, complete verification, then deploy the fix to production and make sure it truly passes all tests.

I think this is very valuable. Today, many teams inside Microsoft are exploring similar ways of working and beginning to learn from one another. These practices are gradually spreading across Microsoft and are also starting to change how teams are organized and operate.

Another case I really like comes from the Azure networking team. In fact, this used to be one of my favorite stories to tell. The team told me that to operate its own global network, Microsoft needs to deal with about 500 fiber network operators around the world. Since this is all physical infrastructure, problems inevitably arise from time to time.

We usually use a professional-sounding word to describe this management work, namely DevOps. But in reality, teams often have to deal with a large number of emails and various ad hoc workflows. So they built a whole Agent system and let the system take direct responsibility for this operations work. Moreover, this operations system is connected to the code repository. In this way, the system manages not only the code repository or the codebase itself, but also the actual operations work around them.

So you can see that the nature of work for technical teams is changing. In the past, teams had to personally complete various software development and operations tasks; now they are starting to build "factories" made up of software and operations processes, and letting these systems execute tasks on their behalf. Of course, engineers are still doing the work; it is just that the way they work has changed.

AI transformation is not about switching frameworks: Microsoft is rebuilding Windows and GitHub

Gergely Orosz: I have been thinking about one question. In AI labs, the work of software engineers is shifting toward helping Agents and the entire execution loop run better. This is already quite common, and these labs are also very willing to share their practices publicly. This is very consistent with the changes you just described.

But if we return to actual work, the situation may not be so simple. Companies like Microsoft will of course have some teams able to try new technologies and build new software factories. For example, platform teams may have extra time and resources to explore these things. But at the same time, you also have a large number of product teams that already have mature products and real customers.

I've found that many companies that have already built mature businesses face this dilemma. They see the various new ways of developing software that AI labs demonstrate, or they hear you talk about software factories now, and they might think: wait, I can't drop everything I'm doing and go build a software factory. And even if I did build one, what would I do with it?

So how do you see the balance between these two? Especially inside Microsoft, how would you explain to engineers what is changing about their work? If they are responsible for a product that is already very successful, consistently profitable, and relied on by a large number of customers, what should they do?

Satya Nadella: That's a very good question. First, we must not do things that don't create value for customers just because a technology looks cool. That's the most basic principle.

Gergely Orosz: Everyone has done that.

Satya Nadella: Exactly, everyone has done it, and I'm no exception. I hope I've learned from those experiences and can do better going forward.

But let's look at a very real example. Today, when I look at CVEs in Windows, that is, publicly disclosed security vulnerabilities, the situation has already changed. Because there are now AI models that can proactively find these vulnerabilities. That means we now have to figure out how to fix all of these vulnerabilities, and therefore need to build a new processing pipeline.

In fact, if you look at what the Windows team is doing, from collecting crash information and analyzing execution traces to ultimately completing fixes, they are actually building a new kind of software factory. But there's an important distinction here: this is not a new project starting from scratch, but a transformation on top of existing systems, what is called a brownfield project.

Windows' existing build system is still Windows' build system. In fact, for all such existing projects, the hardest part is often the build system and CI/CD.

Take GitHub as another example. If you look at the changes it is undergoing underneath, you'll find the same is true. All of a sudden, a large number of coding agents have started working on GitHub, and the platform's usage has grown dramatically, even reaching levels that were hard to imagine in the past.

Gergely Orosz: It has already surpassed the scale of human developers.

Satya Nadella: Exactly. So we have to fundamentally change the entire system, including the Git protocol and the underlying storage systems. We are re-examining and transforming every part of it to ensure they can adapt to this change.

But we have to do this work on top of existing systems, not throw everything out and start over. Of course, we will always carry out some greenfield projects built from scratch, but most work in the real world happens in brownfield environments.

And in brownfield projects, you have to improve the reliability of the system step by step and rethink various core foundational components. From source code management to the build system to CI/CD, everything must work properly in existing projects.

These changes take time, investment, and careful thought. Especially important is that the entire transformation process must follow the correct order of operations. What you do first and what you do later directly affects the final result.

So I hope the teams at Microsoft understand that this transformation is not about us discovering an exciting new technology and then setting up a dedicated team to study it while everyone else in the company continues working the way they always have.

What I really like about this transformation is that everyone in the company has the opportunity to use the new toolchain and ways of working to solve the real problems in front of them. Whether you work on Windows, SQL Server, or a cloud-native service, you can use these new tools to improve your work. I think that's exactly the change we're seeing now.

Gergely Orosz: But to be fair, this sounds not much different from how we've introduced new technologies in the past. For example, when React emerged as a new front-end technology, everyone wanted to use it. But no one was allowed to pause all their work and migrate existing projects to React. Instead, when you develop a new product or add new features to an existing product, you can gradually introduce React and let old and new technologies coexist in the same project.

Satya Nadella: That's a good question. Sometimes I also feel that this situation seems familiar, that it's nothing entirely new. But I think there is indeed a very important difference this time, which is that the fundamental way we get work done is changing, including the entire order of operations and the level of abstraction we operate at.

Actually, one thing has always struck me as interesting. When I first entered the workforce, it happened to be a period of major transition in computing platforms. When I was in college, I mainly used VAX computers, operating them through VT terminals. At that time, it was a mainframe or minicomputer environment, such as VMS systems. Later, I worked at Sun for a few years and started using workstations. And then I joined Microsoft.

Since then, the entire world of software development actually remained relatively stable for a very long period of time. For most of my career, programmers have basically written code in an IDE.

Of course, new technologies kept emerging during this period, but these new technologies were mainly new frameworks and runtime environments, and they did not fundamentally change the basic concepts of software development. Even when mobile computing later emerged, in a sense mobile devices were just smaller PCs, only with new user interfaces and development frameworks.

But this time it is different. We now need to rethink everything: What is a runtime environment? What is a development framework? What should an IDE look like? And how should the entire technology stack be organized?

The questions you just mentioned are all important, because this time, almost every component is changing. This is not just adopting a new technology; the very way we think about software development is changing.

And don't forget, a new model could appear at any time. It could be a more capable frontier model, or it could be an entirely new technological form such as a decision engine. Whenever such a technology appears, the entire way of development may change again. That is also why I think we must be prepared to accept the reality that the entire technological paradigm may undergo a fundamental shift at any time.

So I mainly think about this issue from two aspects.

On the one hand, we should of course learn from past experience. Looking back at how individuals, companies, and teams successfully responded to technological change in the past, and which methods once helped us complete transitions, that experience is always very important.

But on the other hand, we must also keep an open mind and acknowledge that this time may really be different.

Responding to voluntary departures and slower hiring: future opportunities will be different

Gergely Orosz: Yes. For us software engineers, the most striking part of this change is that in the past we would spend most of our time writing code. The same is probably true at Microsoft, where most employees are software engineers or do work closely related to code. In the past, we studied programming in university, accumulated experience in previous jobs, and spent a great deal of time and energy just to be able to write better code.

But now, that part of the work suddenly no longer needs to be done by us personally as it was before. I know that for many people, including myself, especially at the beginning of the change, this is hard to accept. Because we have never seen anything like this in previous technological changes. Every past technological advance usually just added a new tool for us.

So I am curious, when you talk with engineers inside or outside Microsoft, how do you see them understanding and accepting this change? Especially those very excellent engineers who spent decades mastering high-level programming ability, which is itself a very difficult thing.

Satya Nadella: Right, I think you are absolutely right. At least from my observation, whether it is those software engineers who were already excellent in the past, or engineers today who are already able to skillfully use new development methods and achieve very high productivity, they actually still need the same core skills.

What has really changed is the order of operations in the work and the toolchain used. Therefore, I do not think this means that the professional capabilities accumulated in the past are depreciating. On the contrary, we should think about how to use new tools and technologies to make existing expertise more effective. In other words, what needs to change is the way we apply our professional capabilities, not the idea that software engineering itself is no longer important.

I think we are now at a stage where everyone is trying to figure out how to evaluate and recognize new ways of working. And in this process, we may also rediscover the value of past skills, provided, of course, that they still apply in the new environment.

For example, there is indeed a group of young engineers today who have been familiar with AI tools from the very beginning. Interestingly, at the last GitHub Universe conference, I went specifically to meet some university students.

They were the first cohort of university graduates who truly grew up in the AI era. Because when they first entered university, GitHub Copilot already existed. In other words, they have never experienced an IDE era without GitHub Copilot.

This shocked me very much. I suddenly realized that a new generation of developers has grown up. They have been familiar with this new toolchain from the start and can be said to be native users of these tools.

But at the same time, I also see many experienced engineers inside Microsoft who have deep expertise in a certain technical field and at the same time remain curious and willing to learn new ways of working. These people also perform very well in the new development environment.

So I especially want to make sure that Microsoft creates enough opportunities for these employees. Because in the end, the economic returns a person can obtain in their career are very important.

Therefore, we hope that at Microsoft, the skills and professional experience employees have accumulated in the past can continue to be recognized, and at the same time, they also have the opportunity to develop new skills and master the capabilities that the future labor market truly values.

Gergely Orosz: I really like the way you look at these changes, especially what you just mentioned—that recent college graduates and early-career engineers can also take part, and can quickly pick up new ways of working.

However, there's one thing that has been discussed a lot in developer circles recently, and I want to ask you about it directly. Many people are speculating about why Microsoft launched a voluntary retirement program. What exactly does it mean? Some worry whether this could be a prelude to layoffs, because AI is increasing team productivity and there may be less need for as many employees in the future.

So I want to ask you this directly. From what I understand, Microsoft has never launched a program like this before, and that's what caught my attention the most. Also, it is a voluntary program. How did you personally and Microsoft's leadership think about this and ultimately make this decision?

Satya Nadella: This is a very important question. We discussed it a lot internally and ultimately concluded that we have to acknowledge a few realities. First, there will still be a lot of opportunities in the future, but the shape of those opportunities may be different from the past. This holds true even if we only talk about the software engineering field we've been discussing. So first, we need to recognize that new opportunities will definitely emerge.

Next, what we should do is create more of these new opportunities inside the company. That's exactly what we've been discussing. Whether you work on Windows or are involved in AI model training, you should have the opportunity to develop new skills. These skills are valuable not only inside Microsoft but also competitive in the external labor market.

Gergely Orosz: Right.

Satya Nadella: But the issue is that the way work gets done in the future will differ from the past, including team size, workflows within teams, and so on.

This is not to say that we don't want Microsoft's existing 200,000 employees to continue to develop, or even to expand the workforce further. On the contrary, we want everyone to be able to grow. But in the future, even if Microsoft still has 200,000 or even more employees, the staffing and ways of working across the organization will have to change.

If you look at the economic returns of different roles inside Microsoft, you'll see some obvious changes. For example, systems engineers and infrastructure engineers are already very highly paid, and so are researchers working on model training. Certain specialized capabilities are now very sought after in the market and very valuable. So we want to give employees more autonomy to choose.

Frankly speaking, launching this voluntary departure program is largely about giving everyone greater autonomy to choose the position that better suits them based on their long-term career development and economic returns.

I think that's the most important thing.

I've been Microsoft's CEO for many years, and before that I held senior management roles. But ultimately, I also grew up step by step from being an individual contributor (IC).

So when I think about how the company should create opportunities for employees, I often recall what it was like when I was an ordinary engineer, a tech lead, or managing several tech team leads. I start from those experiences and think about what employees really need.

Suppose I were now on some team at Microsoft, and that team had not kept up with the technological transformation—I certainly wouldn't want to be stuck there forever. We have to face reality. I can't sit here and tell everyone that every division at Microsoft already fully understands this change and is advancing the transformation at the same pace. That's not the case. So if the team you're on makes you feel that your career development is limited, I hope you can take action and choose to move somewhere else.

And frankly, there are plenty of other opportunities inside Microsoft itself—you don't necessarily have to leave the company to find a new direction for development. That's another kind of opportunity we want to create for employees. So in this context, we want to give employees greater autonomy, while also clearly recognizing that we are in a period full of turbulence and change.

Of course I'd like to be able to tell everyone that everything will be the same as before, but I can't.

So I want to explain these changes to everyone as transparently as possible. I also want to truly take responsibility, create more opportunities inside the company, and make sure our employees can achieve career growth here.

Gergely Orosz: I think your explanation is very thoughtful and also very tactful. But if I were to understand it in a more direct way, I'd sum it up like this: the world has already changed dramatically. We've seen how quickly the changes brought by Claude Code have come. If a team is slow to react to such changes, or hasn't even realized what's happening, that's very dangerous. There isn't much room left for that kind of slow reaction now. So engineers must recognize that the world has changed, that the work of software engineers will change, and that the tools they use will change.

You can choose to accept this change, actively look for the exciting opportunities in it, understand the various engineering challenges involved in building software factories and new workflows, and learn how to take part in it. But you can also decide that you don't want to do this.

In most companies, if you make the latter choice, you might find yourself in a dilemma. But Microsoft is now actually giving employees another option: if you don't want to continue participating in this transformation, you can choose to leave now, and the company won't hold it against you.

Satya Nadella: I think you can understand it that way. But I'd like to add one more point. This matter is very important to me. We must acknowledge that the discussion around AI has brought people enormous anxiety—really, very serious anxiety. Many people are starting to feel that their fate is no longer in their own hands. This has a lot to do with the way we've discussed the AI revolution in the past.

People often say that the technological singularity may have already arrived, that in the future perhaps only one company will hold the most advanced AI, or that a large number of jobs will cease to exist. All these statements piled together make people anxious. Even someone who is otherwise willing to accept change may feel uneasy because of them.

Gergely Orosz: Right, there's a lot of pressure.

Satya Nadella: So I think we must take this issue seriously. Microsoft is a company with about 200,000 employees, and I know that in the future, everyone's work will change a great deal. For example, one of Microsoft's fastest-growing roles right now is the Forward Deployed Engineer (FDE).

Gergely Orosz: And not just at Microsoft—across the whole industry.

Satya Nadella: Exactly, across the whole industry. If you think about it, in the past, the way an enterprise served customers was usually through an account manager who owned the customer relationship. Next to the account manager were customer technical support staff and what we internally call the CSU, the customer success unit. In addition, there were dedicated technical support staff. Now we also have forward deployed engineer teams.

I think all these roles need to go through a thorough transformation. In a sense, the employees in these jobs should all take part in a Preceptorship program similar to the one for software engineers, to learn new skills and new ways of working. Because the boundaries between these roles are shifting.

I know LinkedIn has made similar adjustments internally. They came up with a concept called "Full Stack Builders," which integrates what were originally different job responsibilities. So I think all these changes mean new opportunities.

But to truly seize these opportunities, companies must complete the hard work, including adjusting organizational structures, reassigning people to roles, creating development opportunities for employees, and providing the corresponding compensation support.

At the same time, we must also rethink how we evaluate employees. How a person performs in a new role, how productive they are, whether their work is excellent—all of this requires evaluation standards that match the new ways of working. For any company that has already built a mature business, these are very difficult but necessary tasks. That's why I think we should of course be glad about the emergence of new technologies and new companies. That's how competitive markets work: new things keep appearing and drive the whole industry forward.

But at the same time, Microsoft is already a 51-year-old company. We should be able to accept our identity and our position with equanimity. We want to continue providing excellent service to customers, and we also want our employees to be well rewarded financially for excellent work.

And our mission has always been to empower every person and every organization to achieve more. That will not change after this transformation either.

Gergely Orosz: Still, I'd like to pin this down clearly and leave a clear record. We just talked about hiring new graduates, so Microsoft is still hiring new graduates and junior engineers, and is willing to invest resources in training them. But many other companies and startups are worried about this now, and some have slowed or even stopped hiring. Because they believe that in the AI era, the people who can use these tools most efficiently are, as we discussed earlier, engineers who have already accumulated deep expertise and can use AI to amplify their abilities. So they are very hesitant about hiring young people who are just entering the workforce.

Satya Nadella: That's a very good question. I think in the current transformation, some trends need to be observed over a slightly longer time span, rather than drawing conclusions based on just one year. Because we are in a phase where a great deal is changing.

First, we need to make sure that employees within the company can be reassigned to the right roles and teams. That's the first step. Even looking at just one team, you have to first adjust staffing and ways of working. Only after completing these adjustments can we further consider what kind of talent we should hire from the industry, or which new graduates we should bring in.

So I think part of the reason for the current hiring slowdown may be that companies still need time to build those so-called new software factories. Only when these new development systems are truly established can new investment take effect. And the investment here is not just tokens, but also people.

We have to acknowledge that the way an AI-native company is organized today is already different. They usually start with one employee and a certain token budget. When that employee pushes their token budget to the limit, the company considers adding the next employee. The newly added employee likewise gets their own token budget, and then the budget of the entire software factory increases accordingly.

Gergely Orosz: Right.

Satya Nadella: This is a way of gradually building an organization from scratch.

But that doesn't mean these companies will stay small forever. If they succeed, they will grow into large enterprises in the future. In fact, some of them have already grown quite large.

I think that in the future, every company may gradually adopt a similar way of organizing, and so will every project team or product team. But for enterprises to complete this reconfiguration, explore new ways of organizing, and find the right combination of people and resources, it will take time. Therefore, I think it is too early to treat short-term phenomena such as a hiring slowdown as a long-term trend.

Gergely Orosz: Now we've discussed how companies build their own software factories and how they change existing ways of working. Next, I want to talk further about how these changes are actually implemented.

Recently, I've noticed a very obvious trend across the tech industry, and I believe you've observed it too: more and more tech companies are adopting open models. Many companies are deploying inference infrastructure themselves. Some companies, such as Revolut, even directly buy hardware for inference, such as NVIDIA B200, and then deploy models on that hardware.

Of course, every company has its own considerations. But from your perspective, Microsoft itself is also providing open model services through platforms such as Foundry. How significant do you think this trend really is? Is it inevitable? I've been thinking about whether there is some similarity between the past open-source software movement and today's open model movement.

Satya Nadella: I think there are definitely similarities between the two. There will still be closed-source models in the future, and different closed-source models will continue to compete with one another. At the same time, open models will become an alternative to closed-source models. Open models can provide greater flexibility.

In fact, when I think about this issue, I often start from another angle: what exactly should an ecosystem composed of frontier models look like? If we no longer cling to the idea that there will be only one frontier model that possesses all the knowledge in the world, then we must consider another possibility. In a sense, there should be as many frontier models as there are companies in the world.

Why do I say that? We can go back to the economist Hayek's explanation of the economic system. He believed that a core feature of how the economy operates is that knowledge is dispersed among different individuals and organizations.

His discussion of the price mechanism is excellent, explaining why prices can work. Because knowledge is often tacit and dispersed throughout the entire economic system. Every company needs to master and apply its own knowledge.

If we accept this, then I would even argue that every company actually possesses two kinds of capital at the same time: human capital and token capital.

If every company will possess both kinds of capital in the future, then token capital can be embodied in an open-weight model, into which the company can embed its own knowledge. That is one way.

Of course, a company's knowledge can also be stored in the context layer. You can even use multiple closed-source models at the same time, collect the traces generated by these models during actual use, and then use that data to train a small model or open-weight model of your own, and use them in combination. In fact, if you look at the Copilot we built, whether GitHub Copilot or other Copilot products, they were designed from the outset as multi-model systems.

I even think that perhaps by the time we next speak, everyone will no longer be hung up on the distinction between open models and closed-source models, but will instead believe that every company should have its own model system. Such a system could even start with a decision engine that determines which model should be used for different tasks.

At the same time, I would separate my context, memory, and action space from any single model. Otherwise, you will be completely locked in by a certain model. In fact, I often think about this question: if your harness, model, and memory are all tightly coupled together, how will you ever escape that system later? More importantly, what are you actually doing? Which things truly belong to you, and which things are actually in the hands of the model? Because the model basically absorbs everything it sees. I think people are gradually understanding this relationship and the implications behind it.

Many people still think this is merely a competition among technology companies. But don't forget that the demand for intelligence has no upper limit. Every bank, every healthcare company, every insurance company, and every analytics firm needs to think carefully about this issue. They must find ways, at the level of system architecture, to manage and control their own learning outcomes and knowledge, and use that knowledge to form their own differentiated competitive advantage.

Against this backdrop, I believe that adopting open-weight models is a path with long-term development potential.

Gergely Orosz: This is very interesting, because I often talk with some mid-sized tech companies and startups, and almost all of these companies are building the things you just mentioned. They are developing their own harnesses, context layers, context graphs, and even their own inference infrastructure.

Gergely Orosz: However, I had never thought about it from this angle before: these engineers building internal AI systems may be doing so precisely for the right strategic reasons, rather than just because they like building new things. They may actually be creating significant value for their companies.

Satya Nadella: Exactly right. The phenomenon you've observed is very interesting. In fact, I would even argue that if you are a bank, you should study how those software companies are staying competitive in the current AI ecosystem and striving to reach the technological frontier.

These companies have not given up control over their own technology systems. In a sense, banks should take a similar approach. Of course, they can leverage the capabilities provided by existing platforms rather than building everything from scratch.

For example, at Microsoft we built a capability layer called the IQ Layer. We extracted the harness used underneath Copilot and GitHub Copilot and made it a standalone foundational capability. Now you can use this harness directly through Foundry as a managed service. Suppose you are building a supply chain system; you can use the harness we provide as a starting point. You can also choose to bring in Pi or other open-source harnesses.

Gergely Orosz: We love Pi.

Satya Nadella: Right. And you can absolutely use it as a managed service. The harness that Microsoft itself is using, validated in actual production environments, can now also be provided to other enterprises.

Next, you can also use the various models in Foundry. That is, you have a harness that can use multiple models as call endpoints, and at the same time you have a context layer that is completely separate from the models. Your memory and context belong to you and are not tied to any particular model. This way, you have a complete model system.

In addition, there is the action space. Various plugins, skills, and connectors can also exist independently, rather than only being accessible and usable by a particular model.

I believe a new type of middleware platform oriented toward model-first development is taking shape. It is somewhat like the classic middleware architectures we were familiar with in the past, but oriented toward AI model systems. Through this architecture, enterprises do not have to be completely locked in by a particular model or vendor.

Moreover, you can evaluate the entire system. In this process, I believe enterprises' own private evals will become increasingly important. Public benchmarks are of course valuable, but you must build your own private evaluation system to measure the outcomes that truly matter to your business. Then, through your own reinforcement learning environment, you can observe how different models perform on real tasks and continuously optimize the entire system.

In fact, we are already seeing this change among customers. Many customers initially choose a frontier model. After using it for a while, they accumulate a large number of execution traces and begin to rethink: since I already know the specific execution flow for a certain task, and it is actually a deterministic workflow, do I still need to keep relying on the latest and most powerful model?

At that point, they may decide to shift toward cost optimization. For example, they might choose an MAI Flash model, plug it into the existing system, and then fine-tune it using the execution traces accumulated earlier. This way, they can complete the same business tasks without relying on a larger model and reduce costs. All of this can be done in Foundry.

Gergely Orosz: What you mean is that many enterprises have already begun to go beyond evaluation systems and further build their own reinforcement learning environments. In this way, they can not only maintain control over the system and manage costs, but also avoid leaking their business data to AI companies that might use that data to train models.

Satya Nadella: Exactly. I often use a simple analogy to understand this issue. In the past, whether it was an insurance company, a bank, or a healthcare institution, they might all decide to adopt a relational database.

First, they deploy a database. Then they may buy a piece of software that runs on top of that database, and that software itself already contains some business logic. Next, the enterprise writes additional business logic based on its own needs to extend the system. Ultimately, the enterprise is able to control its own application and data.

Moreover, throughout this process, the data in the database does not automatically flow to other companies. Even if one day the database vendor tells you that they will no longer provide updates for this database, you can still choose to migrate to another system.

But in the AI era, we must rethink this issue. If your memory has been embedded in the internal representation of a particular model, then when this model company suddenly tells you that it can no longer provide the next model update, how do you plan to migrate your memory out?

Gergely Orosz: And there is also another issue we just discussed: when new foundational building blocks appear, how do you integrate them into your own system?

Because if you rely too heavily on one vendor, or a few vendors, you can only wait for them to decide whether to support these new capabilities. And I think it is easier to build these systems yourself now than in the past. If your team has sufficiently good engineers, you are actually fully capable of doing this work.

Satya Nadella: Exactly. I think there are now two very important enterprise architecture decisions worth discussing. I hope more people will truly start paying attention to these issues in the future.

In fact, as you just said, if you look at development teams in the software industry today, you will find that they are all exploring how to maintain technological independence.

I think this way of thinking should also gradually become common practice in other business domains.

The first question is how enterprises can avoid what I call the "Reverse Information Paradox," that is, they must not leak what is most valuable to them while using AI. As an enterprise, you must be able to control your own learning loop. This involves specific architectural choices: how do you ensure that your context is independent of the model? How do you use multiple models at the same time?

At the same time, your Harness should also be separated from the context and the model. I think only with such an architecture can you truly ensure that you can replace any model at any time. In fact, I have a very simple test: you should be able to replace any model in the system while still continuously achieving better results on your own private evaluation metrics.

If you cannot do this, you must seriously ask yourself: are you still an enterprise that can independently control its own business? Because this means you are no longer truly in control of your own output.

Gergely Orosz: Yes. It is like sitting on a time bomb that could explode at any moment.

Satya Nadella: Exactly. I mean, if you get to that point, you are really in trouble.

Next, there is a second very important issue: enterprises must establish a trust architecture. We now already know that scaling laws do work. As model size and compute continue to increase, models gain new capabilities.

But the problem is that capability growth does not mean the model's degree of alignment will improve in sync. In fact, we still lack sufficient understanding of the internal mechanisms of models. I hope that one day in the future, scientific research will make a breakthrough in this area. But at this stage, the reality we face is that models are becoming more and more capable, yet their reliability is not improving accordingly, and they may even become increasingly unreliable.

This is a very dangerous situation.

Therefore, we must separate intelligence from authority in system architecture.

If an intelligent system both has the authority to perform operations and is not reliable enough, then you will face serious problems. This will actually create enormous insider risk. So we must manage AI agents as a potential insider risk. This means you need to establish a complete trust system, which involves many specific issues.

For example, the model's chain of thought. We need to consider how to present the system's reasoning and decision-making process in language that humans can understand, so that it can be audited and recorded, and ensure that the relevant logs cannot be tampered with. Because model risk does not exist only in the pre-training or reinforcement learning stages. Problems can also arise during test-time compute. For example, through reward hacking, a model may exploit loopholes in the evaluation mechanism to obtain higher rewards rather than truly completing the task we want it to complete. Therefore, we must establish a large number of safety protection mechanisms at runtime.

What I mean by trust architecture is to ensure that we can manage models and agents as potential insider risks, monitor them, establish observability, and take necessary protective measures. At the same time, we must also ensure that enterprises can always control their own learning loop.

Gergely Orosz: As an engineer, hearing these discussions and combining them with what I've observed myself, my biggest takeaway is this: there is still a huge amount of entirely new engineering work to be done in the future. We need to build many systems that have never existed before, and there aren't even mature design blueprints we can refer to yet.

I think the best approach right now is probably to build things hands-on yourself, while also talking with peers who are solving similar problems. Maybe in five or ten years, we'll have mature architecture blueprints, industry standards, and certification systems. But at least for now, this is all work that engineers genuinely need to do.

Satya Nadella: Exactly right. In fact, we're holding the Ignite conference next week, and I'm really looking forward to it.

Because I hope we can use this opportunity to clearly convey one message to everyone: these things are achievable, and we already have some architecture blueprints we can draw on. Right now, there's already a great deal of innovation happening in how enterprises build these systems.

I think we're entering a new phase. People are no longer just focused on those eye-catching new technologies, and they're no longer trying a technology merely because it's novel. Instead, enterprises need to truly sit down and seriously think about one question: how exactly do I use these technologies to create business value for my company? As people begin to discuss these questions more deeply, the practices that lead to success will gradually become clearer.

Gergely Orosz: However, as an engineer, I feel there's still one very obvious gap right now. The AI models we just discussed basically all run in the cloud, that is, on other companies' servers. Or, you need to buy a very expensive B200 GPU, which I myself simply can't afford, and my company may not necessarily be willing to procure one for me.

Of course, if you can get such hardware, that's indeed fortunate. But wouldn't it be even better if these models could run directly on my laptop?

Satya Nadella: That's a great question.

Gergely Orosz: So far, running AI models locally is still fairly difficult, and it often requires a lot of complex configuration and makeshift solutions.

But interestingly, Microsoft seems to be innovating in this area. Scott Hanselman recently showed me a new Surface Ultra laptop. Now I really want to try it myself, because it's equipped with a chip that can run coding models locally.

So, what role do you think local models should play in the overall AI workflow? From a developer's perspective, I feel this is exactly the piece that's urgently missing right now. But maybe it's just me? After all, you talk to far more people than I do.

Satya Nadella: One thing we place great importance on right now is ensuring that the PC form factor can continue to innovate in the AI era. For me, I've always thought about this in one way, and our product development is advancing in this direction as well. I've always believed that distributed computing will always be distributed.

That being the case, why don't we make full use of all the computing power and token resources available to us, rather than relying only on the cloud? This is also one of the important starting points for our development of Ultra.

Of course, this kind of innovation is far from being done by Microsoft alone. Whether it's NVIDIA, AMD, Qualcomm, or Intel, they've all made a lot of progress at the chip and system level. And an interesting phenomenon has already emerged: last year's frontier models may already be able to run on your laptop today; last quarter's frontier models may already be able to run on a desktop today. That's the capability shift we're seeing right now.

Gergely Orosz: It's a bit like the process of PC performance continuously improving in the past.

Satya Nadella: Exactly right. So, once we have this kind of local computing capability, I come back to the decision engine and model router I've been discussing all along. For example, we have a model routing mechanism in GitHub, I think it's called Hydra Fusion, though I'm a bit fuzzy on the exact name. I really like what GitHub has done in this area. Because when using Copilot now, I actually rarely need to manually select a model myself anymore.

Our goal is to let the router automatically select the most suitable model based on the specific task. That also means local models can become part of the overall model system. In fact, when I use Ultra now, sometimes I suddenly hear the computer fan start spinning. That usually means the system is calling a local model. This is especially valuable in an Agent Swarm, when you're running multiple sub-agents at the same time.

You can have some of those sub-agents call local models while other sub-agents use cloud models. The two can work together within the same workflow to complete tasks. From a system architecture perspective, this approach is reasonable; from an economic cost perspective, it is equally reasonable. So I think we are entering a new era that could be called "Hybrid Intelligence." Cloud computing will continue to grow, because the demand for tokens is almost unlimited. But at the same time, we can also begin to view the various forms of compute on edge devices as factories capable of producing tokens. In fact, I would prefer to call this capability "Unmetered Intelligence."

Gergely Orosz: Yes, because then you don't need to worry about exactly how much intelligence resource you're using.

Satya Nadella: Exactly.

Gergely Orosz: I feel like these things are starting to connect now. Speaking of Microsoft's MAI models, such as MAI Code and Flash 1.1, frankly, they didn't leave a particularly strong impression on me. I think most people probably didn't find them all that impressive either.

But there is one detail that really interests me. In the past, I always thought that if you wanted to run local models on an ordinary laptop, you had to use open models. But although MAI Code is a closed-source model, it can be downloaded onto a Windows PC and run directly locally. This shows that Microsoft already has the corresponding infrastructure in place.

This got me thinking: will more closed-source models adopt this approach in the future? For example, I could directly choose the models I need on my laptop, download them to run locally, and possibly for free or at a very low cost.

Satya Nadella: As you just mentioned, actually deploying models like Code Flash onto laptops is a very important priority for us right now. We are very excited about it as well.

For example, if you look at the Code tab in Copilot, you'll find that even without using GitHub Copilot, you can directly use these models on a PC to write code, draft documents, or build applications. That really is exciting.

However, I want to step back a bit and explain how Microsoft is laying out its MAI models. First, through our partnership with OpenAI, we have already been able to use OpenAI's models, and we will continue to use them in the future.

On that foundation, we want to innovate from scratch and build an entirely new model family. Innovating from scratch here means that we complete the fundamental research and training of the models ourselves.

In fact, we have already disclosed information about the MAI-2 Base model, including the pre-training process. I think this is one of the most thoroughly disclosed cases of model pre-training approaches and training mechanisms to date.

I highly recommend your listeners take a look at the relevant materials. Some outsiders have even told me that this is one of the most detailed technical descriptions of pre-training they have ever seen. Because there are not many places where such detailed pre-training information is publicly available. And this is a completely independent, from-scratch pre-training implementation. So we will continue to advance this work.

But at the same time, where we really want to achieve innovation is in creating new breakthrough points on the frontier curve of model capabilities. We can leverage Microsoft's own products and application scenarios—whether cybersecurity, knowledge work, or programming—to explore how to push the boundaries of model capabilities.

And what we pursue is not just improved model capabilities, but also efficiency in two respects: first, improving compute efficiency during training, that is, FLOPs efficiency; second, improving token efficiency during deployment.

As we enter an era where high-level task intent can be handed off to multiple sub-agents, these sub-agents can absolutely use different model families. Therefore, I think that in the future it will not necessarily be necessary to always be tied to a single model family. As long as different model options exist, agents can intelligently select the most suitable combination of models to complete tasks in the most efficient way. That is also our goal: to provide developers and enterprises with more choices, rather than making them dependent on a single model family.

Some advice for software engineers

Gergely Orosz: I really like your emphasis on choice. As a developer, I like being able to freely choose different tools and models. This also helps promote competition and brings benefits such as better pricing.

Finally, I want to ask for some career advice. The pace of technological change right now is really too fast. I have spoken with many people who have worked in this industry for years, and they all say they have experienced similar technological shifts in the past—perhaps not on this scale, but change has never happened this quickly. And you have been through multiple rounds of technological change. When you started your career, the entire industry was completely different from today.

Satya Nadella: I think the answer is actually hidden in the things we just discussed. Frankly, even for myself, the most important thing is to make sure I truly understand what this change really means. We can't just focus on headlines, and we can't just stay at the level of discussing various hot topics. I really like X; it's a great platform. But understanding technological change can't just be about chasing round after round of hype, and it can't just be about constantly joining discussions. Of course, saying this on a podcast may sound a bit ironic.

But my advice is: talk a little less, do a little more, learn a little more, and really get hands-on to experience these new technologies. Frankly, even for myself, if I could change the ratio of time spent discussing versus actually doing, I would definitely do so.

Now is exactly the time to do this. If I could give only one piece of advice, then whether you are an engineer who has been working for many years, a CEO like me, or a recent college graduate, I would advise you to spend as much time as possible learning, getting hands-on, and joining teams that are truly using new technologies to do work. I think this is more important than anything else.

Because sometimes I also look back and think, when am I at my best? The answer is often when I am in a student-like state, staying curious and continuously learning new knowledge. So let's go back to school and become students again.

Gergely Orosz: Satya, thank you very much for doing this interview.

Satya Nadella: Thank you very much for the invitation; I'm also very happy to be on this show.

Interview Summary

Gergely Orosz: This was truly a wonderful interview. We discussed many different topics with Satya, but one question ran through it all: when AI makes code generation cheaper and cheaper, which parts of software engineering will actually become more important?

We talked about how the work before and after writing code—that is, planning and verification—will become more important. In the future, software engineers will spend more time on these stages. I also shared a phenomenon I've observed: many tech companies are building their own Coding Harness, context layers, and AI infrastructure.

In the past, I always thought this was just because engineers like using new technologies and like building various systems hands-on. But Satya pointed out that if a company cannot control its own AI infrastructure and AI intellectual property, then from a strategic perspective, this is actually a self-destructive strategy.

He even believes that every successful company in the future will build its own AI infrastructure. Those companies that rely entirely on a single vendor or a single AI lab may be making a serious strategic mistake. In that case, those of us engineers who like building new things may actually gain more opportunities because of this. I can foresee that there will be a great deal of work for us to do in the future, including building new types of AI infrastructure and software factories inside enterprises.

In addition, the role of software engineers and what companies expect from them are also changing. Satya mentioned that the Forward Deployed Engineer (FDE) is currently one of the fastest-growing roles inside Microsoft. A few years ago, this role was not common. He also expects that Microsoft will undergo a large amount of organizational adjustment internally, that team sizes may become smaller, and that employees' job responsibilities will also change.

For employees who are unwilling to go through this transformation, which may be more drastic than in the past, Microsoft's voluntary departure program offers an opportunity to leave. I think such changes will probably not happen only at Microsoft. Organizational restructuring, role adjustments, and changes in ways of working are likely to appear at many other tech companies as well, and the degree of change may be more obvious than in the past.

In the end, this interview actually left me even more motivated about the future.

For example, new AI building blocks such as decision models are emerging, while some other building blocks have not even been invented yet. We need to use these new building blocks to develop new systems, decide where each capability should go, how systems should adjust, what kind of architecture makes sense, and how to deploy these systems and continuously learn and improve in actual operation. These will all become new problems that software engineers need to face.

Thank you for listening, and see you next time!

This article comes from the WeChat public account "InfoQ" (ID: infoqchina), author: Lin Qibei, published by 36Kr with authorization.

Source

36Kr · AI