AI Coding Agents End Programming Language Lock-In: Code Migration Enters the Reversible Era

Programming Languages Are No Longer Lock-In: A Disruptive Perspective

Simon Willison recently shared a thought-provoking story, along with comments from Mitchell Hashimoto (co-founder of HashiCorp) about Bun's migration from Zig to Rust. Mitchell Hashimoto is one of the most influential technical figures in infrastructure automation—HashiCorp's tools like Terraform and Vault are used by millions of developers worldwide. After leaving HashiCorp in late 2023, he has continued to focus on the intersection of AI and systems programming. Bun—a JavaScript runtime known for its high performance—originally chose the relatively niche Zig language for its underlying implementation, but is now seriously considering migrating to Rust. The fact that this kind of foundational infrastructure-level language switch can even be put on the agenda is itself a powerful signal.

The core insight boils down to one sentence:

Programming languages used to be LOCK IN, and they're increasingly not so.

Behind this observation is the fact that AI coding agents are fundamentally changing the economics of software development.

Real-World Case: Completing a Cross-Platform Rewrite with AI Coding Agents

At a tech conference, Simon met an engineer from a mid-size tech company. This company had a pair of "legendary" iPhone and Android native apps—"legendary" being both a nod to their historical significance and a hint at the heavy burden of maintaining such legacy code.

The engineer told him they had just accomplished an engineering feat that might have previously taken months or even years: using AI coding agents to completely rewrite both native apps in React Native.

React Native is a cross-platform mobile development framework open-sourced by Meta (formerly Facebook) in 2015, allowing developers to write applications in JavaScript/TypeScript that run on both iOS and Android. Early React Native was heavily criticized for performance bottlenecks and native module compatibility issues, and many teams reverted to native development after trying it. But starting in 2022, Meta introduced a completely New Architecture, including the Fabric renderer and TurboModules, dramatically improving communication efficiency between the JavaScript and native layers. The maturation of the Expo ecosystem has also significantly lowered the development barrier, making React Native once again a mainstream choice for cross-platform development in 2024-2025.

Simon immediately posed a pointed question: if AI coding agents can already dramatically reduce the cost of simultaneously maintaining two codebases for iOS and Android, why bother migrating to React Native?

The answer contained two layers:

1. React Native has matured enough in recent years to cover all their needs—a rational judgment at the technology selection level.
2. If this decision proves wrong, they can use AI agents to migrate back to native—this is the truly disruptive shift in thinking.

The Economics of Software Rewrites Are Being Reshaped by AI

The Past: Code Rewrites Were a Gamble

In traditional software engineering, large-scale code rewrites were among the highest-risk decisions possible. Joel Spolsky—co-founder of Stack Overflow and renowned tech blogger—wrote in his 2000 article "Things You Should Never Do," using the painful lesson of the Netscape browser as an example, arguing that rewriting code from scratch is "the single worst strategic mistake that any software company can make." Netscape decided in 1998 to rewrite their browser engine from zero, took three years to release Netscape 6.0, and during that time their market share was thoroughly consumed by Internet Explorer. Spolsky pointed out that the seemingly ugly patches and special handling in old code are often the crystallization of years of real bug fixes and edge case handling—rewriting means losing all that implicit knowledge. This article had a profound influence in the software engineering world, and "don't rewrite" became an industry mantra for over twenty years.

Choosing a programming language, a framework, a tech stack was essentially a semi-permanent commitment. Migration costs were so high that many companies would rather patch an ill-fitting tech stack than dare to speak of rewriting. This is what's known as technology lock-in.

Technology lock-in is a core concept in information economics, first systematically studied by economists like Joseph Farrell and Paul Klemperer. The essence of the lock-in effect is switching cost: when the cost of migrating from one technology to another is high enough to prevent migration, lock-in forms. In software development, programming language lock-in includes not only the direct cost of code rewriting, but also team skill retraining, toolchain rebuilding, third-party library ecosystem adaptation, and the risk to business continuity during migration. Historically, this lock-in effect has given rise to many "path dependency" phenomena—massive financial systems still run on COBOL today, not because COBOL is the best choice, but because migration costs far exceed maintenance costs.

The Present: AI Agents Make Rewrites a Reversible Decision

When AI coding agents can complete large-scale code migrations at extremely low cost, the entire decision framework undergoes a qualitative change. Technology selection transforms from an "irreversible strategic decision" into a "reversible tactical choice."

Coding Agents are one of the fastest-growing directions in AI applications during 2024-2025, with representative products including Cursor, Claude Code, Devin, OpenAI Codex, and GitHub Copilot's Agent mode. Unlike early code completion tools, coding agents can understand high-level task descriptions, autonomously plan execution steps, read and modify multiple files, run tests, and iteratively fix issues based on results. In code migration scenarios, agents can analyze the source language's code structure and semantics, understand business logic intent, and then generate functionally equivalent implementations in the target language. The key breakthrough enabling this capability comes from the expansion of large language model context windows (from 4K to 128K and beyond) and the maturation of tool use capabilities, allowing agents to handle complex cross-file, cross-module dependencies in real projects.

This means:

• Trial-and-error costs drop dramatically: Chose the wrong tech stack? No problem, just migrate again.
• Decision speed can accelerate: No need to spend months on technical evaluations and POCs, because the cost of mistakes has shrunk.
• Legacy systems are no longer shackles: Those "legendary" systems with a decade of accumulated technical debt finally have an economically viable path to modernization.

From an economics perspective, the dissolution of lock-in effects by AI agents is essentially a dramatic reduction in the key variable of switching costs. When switching costs approach zero, lock-in effects naturally collapse.

Deeper Implications: What's the Real Moat Beyond Code?

The Value of Code Itself Is Declining

If programming languages and frameworks no longer constitute lock-in, then the value of code itself as a competitive barrier is continuously declining. What's truly valuable is no longer "what language it's written in" or "how many lines there are," but rather:

• Business logic and domain knowledge: The "why we do it this way" behind the code matters more than the "how."
• Data and user relationships: These are assets that AI cannot easily replicate.
• Architectural decisions and system design: High-level design thinking still requires human judgment.

What This Means for Developers

This doesn't mean learning programming languages becomes meaningless. Quite the opposite—developers who understand multiple languages and paradigms will be more valuable, because they can better guide AI agents through cross-language migrations and more accurately evaluate the applicability of different tech stacks.

But the mindset of "I'm an expert in language X, so everything should be written in X" is indeed losing its footing.

AI-Driven Code Migration Still Calls for Cautious Optimism

Of course, we also need to keep several practical issues in mind:

1. How do we ensure the quality of AI-driven rewrites? Does automatically migrated code truly preserve all edge cases and implicit logic? This requires rigorous test coverage.
2. Not all systems are suitable for automated migration. Highly complex distributed systems and code involving low-level hardware interactions still present significant migration challenges. Code in distributed systems contains not only business logic but is deeply coupled with network communication protocols, consistency guarantees, fault recovery strategies, and concurrency control models. For example, a telecom system built with Erlang/OTP has fault tolerance and hot code upgrade capabilities that are language runtime-level features—they cannot be simply migrated to other languages through code translation. Similarly, low-level code involving kernel modules, device drivers, or real-time operating systems depends on a specific language's precise control over memory layout, interrupt handling, and timing. In these scenarios, AI agents face not just syntax translation problems but need to understand runtime semantic differences across target platforms—this remains a major challenge for current technology.
3. This trend is still in its early stages. While the cases above are exciting, we still need more large-scale validation.

However, the direction is already clear. As Mitchell Hashimoto stated, the lock-in effect of programming languages is dissolving. And the core force driving this change is increasingly powerful AI coding agents.

For technology decision-makers, this is perhaps the most important new insight to internalize: In the AI era, reversibility in technology selection is becoming the norm, not the exception.