[KongchangAI]
· 5 min read· 2,938 words

AI Code Generation Is Getting Cheaper—Validation Is the Real Challenge

AI Code Generation Is Getting Cheaper—Validation Is the Real Challenge

As code generation becomes cheaper, validation becomes the bottleneck. Nadella advocates a software factory and separation of permissions to ensure delivery quality.

Based on Microsoft CEO Nadella's interview, the article notes that coding agents have drastically cut code generation costs, but validation has become prominent—agents may delete failing tests for "all green." Nadella advocates splitting tasks small, verifying step by step, using different model families for review, and connecting production records, failure reproduction, and tests into a repeatable "software factory." Enterprises must decouple models, context, and agent frameworks and separate intelligence from permissions. Organizationally, FDE roles are growing, and newcomers need to build judgment through projects.

When coding agents can deliver seemingly "all-green" test results in seconds, teams find it even harder to judge whether a problem is actually fixed. In his analysis of Microsoft CEO Satya Nadella's interview, Bilibili creator Gua Ge highlights this contradiction with a very concrete scenario: the agent deletes the originally failing test case just to make the tests pass. Green does appear, but one piece of evidence is gone.

After Code Generation Gets Cheaper, the Bottleneck Shifts to Validation

In his interview with The Pragmatic Engineer, Nadella repeatedly mentions the "validation problem." His conversation partner is Gergely Orosz, and they discuss a very practical question: as code generation becomes cheaper and cheaper, where should software teams spend their time?

Nadella's answer is not to write faster, but to turn seemingly finished changes into shippable software step by step. He even says that his ideal next job would be to go back to the front lines and join a team that treats code as something to be dug out. As CEO he can see a lot of progress, but he hasn't personally done projects under this way of working. What he wants to learn are the judgments along the delivery chain.

This chain of judgment becomes clearer in the evolution of GitHub Copilot's form. It started with completing the next small snippet of code in the editor, with the human checking as they write; by the Cursor generation, the model could take on a small task and modify several related pieces of code itself. Nadella mentions that Microsoft also caught up with agent mode, and that the emergence of Claude Code surprised the team—he attributes this to a leap in Anthropic's model capabilities. Some tasks can be assigned directly in the command line, and you wait for the agent to hand back a complete set of changes.

According to his observation, the editor's central role in this kind of workflow began to fade after about six months. The editor is still useful, but its purpose has changed: it's more convenient for writing specifications, organizing documents for the agent to read, and checking the results it hands back.

Let him look back at the same set of changes

Specifications Must Clarify the "Blank Spaces" in Advance

In the past, when writing a program, if you encountered an edge case, you could add a check when you got there. Now, when you send off the whole task, the agent will handle the blank spaces itself. If the requirement only says "make the import flow smoother," it has to guess whether to overwrite, merge, or stop and ask when it encounters duplicate records. All these options can be made to work, but they will ultimately change the data in users' hands.

Nadella's approach is to split tasks small and verify each step as it's completed. Specifications need to clarify in advance exactly these kinds of choices. The entry point has changed, and the way engineers give instructions must change accordingly. No matter how carefully you design around one generation of models, the next generation may change the part of the work users are willing to do by hand.

Bring in a Different Model Family for Review

In the validation stage, Nadella mentions an easily overlooked practice: using a different model family for review. The model that generated the code has already made many decisions along one interpretation; asking it to review the same set of changes again may follow the original line of thinking and walk through the same errors. Bringing in a different model for review adds a chance to catch blind spots.

He also cares about whether teams can turn failures that have already occurred into tests. If a problem only appears under a specific sequence of operations, before fixing it, first have the test reproduce that sequence, then run it again after the fix to see whether the same operations still fail. This way, when the agent later changes nearby logic, the team has a way to know whether the old problem has returned.

A more complete chain is to connect production records: a user actually encounters a crash, the system leaves behind runtime clues from that moment, and the team uses these clues to reproduce the problem, propose a fix, verify it with tests, and then decide how to release. Nadella uses this chain to explain his understanding of self-improvement—each round of improvement has a checkable result, and the next round uses new runtime records to see whether the fix addresses the real problem.

Together, these efforts come close to what he calls a "software factory": how tasks are handed to agents, how exceptions are recorded, who checks results, and under what conditions releases can happen—forming a process that can run repeatedly. Each delivery includes not only code but also accumulates design documents, tests, and failure records. A new employee told him that taking over a codebase with documentation to consult is actually easier—when something is unclear, you can follow the materials and ask questions, spending less time asking around for people.

Where the program executes

Model Family refers to a series of models developed by the same organization based on the same architecture and training methods, such as OpenAI's GPT series, Anthropic's Claude series, and Meta's Llama series. Different families differ in pre-training data, alignment strategies, and reasoning styles, so they may have different understandings and blind spots for the same piece of code. Using models from different families for review is equivalent to introducing an independent second opinion, which can reduce the risk of the generating model reinforcing its own errors. In engineering, this practice is called "heterogeneous review," similar to the principle in traditional code review of avoiding self-review by the author.

From Azure Networking to Windows: Bringing Operations Work into the Code Repository

Nadella gives an example that sounds far removed from writing code. Microsoft's global Azure network involves about 500 fiber optic carriers. When lines have problems, the team has to communicate with different carriers, and much of the coordination used to be done through email and ad hoc processes. Later, the Azure networking team and an agent system connected operations work with the code repository, letting the system handle this business that happens every day and making the results traceable.

Moving the same idea to Windows brings different difficulties. The Windows team is connecting the process from crash recording to fix into a new workflow. Every fix ultimately has to compile in the existing build system and go through the existing product's testing and delivery processes. For a product that already has a large user base, how to build, how to merge changes, how to release and validate, and which step comes before which—all of this must be carefully considered.

After coding agents flood into GitHub, the scale of operations the platform must handle also grows, and even the underlying protocols and storage must be reconsidered. People used to worry that code was written too slowly; now code arrives in concentrated batches, and the systems responsible for building, checking, and delivering must keep up.

Orosz uses the earlier adoption of React as an analogy: existing products must continue to be developed, and the new framework can be adopted bit by bit when building new features. Nadella agrees with this pace of changing while doing, but he cares more about the fact that when model capabilities change, teams may need to simultaneously rethink how the editor is used, how tasks are divided, where programs execute, and what results are verified against.

Turn Stabilized Judgments into Components

Once some processes have stabilized, is it still necessary to call a general-purpose model to think through everything from scratch every time? Nadella talks about the Xbox team's example of managing community feedback: a large amount of feedback comes in, and the system needs to continuously make some judgments. The team can turn this kind of judgment into a callable component. When new feedback arrives, it uses this component to handle decisions; the model gives probabilities for different options, and the downstream program then decides according to its own rules how to use that result. This also has the potential to save tokens spent on repeated generation.

He compares this kind of decision model to a spreadsheet in Excel—a frequently repeated set of operations can be written out in advance and called when needed. Orosz compares it to a stored procedure in a database, and Nadella agrees with the analogy. What engineers need to do is judge which steps have stabilized enough to be handled this way, and under what circumstances decisions should be handed back to humans.

Stored Procedure is a set of SQL statements precompiled and saved in a database that can be repeatedly called to execute specific business logic. Nadella agrees with comparing stable decisions made into components to stored procedures because both emphasize encapsulating high-frequency, clearly defined processing logic into reusable units to reduce the overhead of recalculating from scratch each time. In agent systems, such components are usually a small classification model or rule engine that receives input and outputs probabilities or decisions, based on which the main process acts. Unlike general large models, they specialize in narrow tasks, with lower invocation cost, lower latency, and easier auditing and version control.

After Switching Models, What Can You Take With You?

Once a company starts accumulating its own rules, documents, and tests, the next question is: if you switch to another model, can these things still be used?

Nadella uses banks as an example. In the past, banks could run their own software on a vendor's database; in the future, if they want to switch databases, they can start migrating from the data and business rules they hold. If historical records, business knowledge, and the agent's way of working are all placed in a tightly coupled service, then when the vendor stops updating, the first question to answer is "what can you take with you."

He is talking about the same thing when discussing open-weight models. A company has knowledge accumulated by employees over many years—for example, who to confirm with first when encountering a certain exception. This knowledge can be placed in internal materials that the model can read, or the company can train and deploy models according to its own tasks. His architectural approach is to let the model, the context, and the framework that orchestrates agents each have their own interfaces: the framework decides how work is handed off and which tools can be called under what conditions, while business documents and interaction records are controlled by the enterprise. This way, models can be replaced one by one, and teams can use the same set of business tasks to compare candidate solutions.

The way to test whether an enterprise has mastered this system is very concrete: after replacing a model, can it still use its own evaluations to continue improving business results?

Separate Intelligence from Permissions

After evaluation passes, there is still the question of how much authority the agent has. A model that can give good advice, once connected to internal tools, may actually execute operations. Nadella says enterprises should manage agents like internal risk, separating intelligence from permissions. The same agent can read an operations record and give handling suggestions, while actions that would actually change production systems are controlled by a separate authorization mechanism, with auditable records of what tools it called and what operations it performed.

These constraints must take effect while the system executes tasks. A more capable model only means it can take on more complex work; the system still must decide what it is allowed to do. If something goes wrong, the team can follow the logs to determine whether the problem lies in judgment, authorization, or execution.

A model that can give good advice

Local Devices Are Also Token Factories

Nadella extends this idea to computers. He says that when using the Surface Laptop Ultra, he sometimes hears the fan spin up because a task called a local model. His vision is that the same task can be split among multiple sub-agents, some calling models on the computer and some going to the cloud, with a routing system choosing. He calls local devices token factories: work that can normally be handled on your own computer uses the device's own compute, saving a cloud fee billed by invocation volume, while more difficult tasks can still use cloud models. He calls this hybrid intelligence.

Microsoft's model layout follows the same logic. According to what he says in the interview, Microsoft will continue to use OpenAI's models and will also train its own MAI models from scratch, exploring in work scenarios such as coding support how to complete tasks at a more appropriate cost.

Hybrid AI refers to combining small models on local devices with large cloud models, with a routing system dynamically allocating computing resources based on task complexity, latency requirements, and cost budgets. Local models handle privacy-sensitive or low-latency tasks, while cloud models handle complex reasoning. This architecture reduces dependence on cloud APIs and token-based billing costs while retaining cloud elasticity. Microsoft's Windows AI Foundry and Copilot+ PC are implementations of this idea; developers can call local NPU compute through system APIs to achieve device-cloud collaboration.

Organization and Newcomers: Roles Will Change, and Judgment Is Harder to Replace

The more processes a company changes, the more employees want to know what their original job will become. Orosz directly asks whether voluntary severance plans are a precursor to future layoffs. Nadella's answer lands on staffing: the team sizes and ways of working for Microsoft's roughly 200,000 employees will all change. He hopes to give employees more choices, and also mentions that even within Microsoft, teams are transforming at different speeds.

He mentions that Forward Deployed Engineer (FDE) is one of Microsoft's fastest-growing roles. This kind of work is close to customers: it requires bringing the problems customers actually encounter back into the technical process, and then putting new systems into the business to run. Organizational adjustments also include arranging people for new positions, providing training opportunities and compensation support, and figuring out how to evaluate a person's performance in the new work.

For new graduates, the question is another layer: the team itself is still experimenting with how much development work to give to agents, how much to keep for people, and how much model invocation budget to give each person. At this point, bringing a newcomer in—what part of the work to teach them and how to get them started—may differ from previous arrangements. Nadella believes this may explain part of the current slowdown in entry-level hiring, and he wants to extend the observation period and wait until teams figure out new staffing and working methods before judging.

This also gives a concrete goal to Microsoft's mentorship program with Carnegie Mellon University. Today's newcomers can still read code, and they also need to learn under the guidance of experienced people to ask: why look at this design document first, why this change needs an additional test, and when the agent hands back several seemingly feasible implementations at once, on what basis do you choose one.

Nadella says he has seen a group of students who encountered Copilot in college and treat agents as a natural tool; he has also seen veteran engineers with deep domain knowledge who are willing to learn new methods remain highly effective under new ways of working. The former are familiar with how to hand off tasks, while the latter often know where problems are likely to arise and what results are worth suspecting. When these two kinds of experience meet in the same project, there is an opportunity to turn faster generation speed into real delivery capability for the team.

Learn that way of working

Back to That Patch of Green

At the end of the interview, Nadella says that if he could adjust the ratio of his "talking" and "doing," he would spend more time doing. No matter how many demos you watch, it is hard to replace holding a failed result yourself, reproducing the problem, trying to fix it, and then seeing whether the fix passes the checks.

Back to the example at the beginning: the agent quickly hands in an all-green test result, and the team must judge what that patch of green actually shows. They need to know which checks were really performed and whether the places that failed were tested again. The easier code is to generate, the more opportunity engineers have to go a bit deeper—clarify intent, verify results, and leave what was learned from solving this problem for next time. By then, the results the agent hands back may become something the whole team can continue to use.

One-line Summary

As code generation becomes cheaper, validation becomes the bottleneck. Nadella advocates a software factory and separation of permissions to ensure delivery quality.

Paragraph Summary

Based on Microsoft CEO Nadella's interview, the article points out that coding agents have drastically reduced the cost of code generation, but the validation problem has become prominent—agents may delete failing tests to get "all green." Nadella advocates splitting tasks small and verifying step by step, using different model families for review, and connecting production records, failure reproduction, and tests into a repeatable "software factory." Enterprises also need to decouple models, context, and agent frameworks, and separate intelligence from permissions to ensure they can still evaluate independently after switching models. Organizationally, roles such as FDE are growing, and newcomers need to develop judgment in projects.

#AI code generation#validation#coding agents#software factory#Satya Nadella#multi-model review#separation of permissions
Share:

Related articles