#

Key takeaways

• Microsoft says AI agents help modernize very large codebases.

• The company pairs agents with static analysis, testing, and formal verification.

• Human experts still approve knowledge bases and handle unclear cases.

• Microsoft says verification is harder than generating edits.

• The source reports no Moroccan deployment or partnership.

Microsoft's verification-first approach

Microsoft published a technical account on October 26 about using AI agents to modernize very large software codebases. The projects mentioned include Windows and Azure. The authors describe work that ranges from moving a codebase of roughly 400 million lines to another compiler toolchain to rewriting legacy C and C plus plus components in Rust.

The central message is simple. Producing code edits is easier than proving those edits preserve behavior, security, and engineering intent. Microsoft frames its work around that gap. The company says it has combined agents with static analysis, testing, and formal verification since 2024.

How the agent workflow is structured

Microsoft describes a migration pattern where agents first derive a candidate knowledge base from sampled findings. A reviewer agent then checks proposed fixes for correctness, minimality, consistency, and maintainability. Human experts approve the knowledge base and handle novel or ambiguous cases. They do not review every repetitive edit.

This setup shifts some work from manual review to agent planning and tool use. The authors say the agents increasingly plan work and call tools built by engineers. That suggests a workflow where the agent does not act alone. It operates inside a controlled engineering process.

Language modernization and testing

For language modernization, Microsoft favors translating one user-visible feature at a time. The company pairs that approach with scenario tests and differential comparisons against the original behavior. It also holds some tests back from the agent. That is meant to probe robustness.

This is an important operational detail. The source shows that Microsoft is not treating code generation as the final step. It is using tests to compare outputs, expose differences, and check whether the new code behaves like the old code. The process is designed to catch regressions before they spread across a large system.

Formal specifications and Verus

Microsoft also describes a more recent step. It extracts formal specifications from source code and uses Verus to check translated Rust against those specifications. This adds another layer of verification beyond testing and static analysis.

The authors also leave open a key question. They ask whether AI-inferred specifications capture intended behavior rather than existing bugs. That is a meaningful limitation. If a specification reflects a bug already present in the source, then verification may confirm the wrong behavior with high confidence.

What the report does and does not claim

The source is careful about scope. It presents Microsoft's engineering approach. It does not claim that all generated code or all migrations are verified. It also does not say that every edit is safe by default. Instead, it shows a layered process that combines agents, reviewers, tests, and formal methods.

That distinction matters. The report is about how Microsoft tries to make agent-led modernization trustworthy. It is not a general guarantee about AI coding systems. The value comes from the surrounding controls, not from generation alone.

Morocco relevance

The source reports no Moroccan deployment or partnership. For readers, the global lesson is conditional: if an organization uses AI agents for modernization, it should pair them with review, testing, and verification rather than trusting generated edits on their own.

Why this matters for engineering teams

The article highlights a practical pattern for large migrations. Break the work into smaller units. Compare behavior against the original system. Keep humans in the loop for ambiguous cases. Use formal checks where possible.

It also shows that verification can be staged. Some checks happen through tests. Some happen through reviewer agents. Some happen through formal specifications. That layered model is the main idea in the source. It is also the clearest signal that modernization at scale depends on process, not just model output.