The dread of a legacy migration is a universal experience for software engineers. It usually begins with a daunting spreadsheet of thousands of files and ends with months of tedious, manual translation, where a single misplaced pointer or a misunderstood memory lifetime can crash an entire system. For years, developers have used AI to help write individual functions or debug isolated snippets, but the scale of a full-system port remained a human burden. The bottleneck was not just the AI's knowledge, but its architecture; a single chat session cannot hold the cognitive load of a million-line codebase without losing the thread of the original plan.

The 11-Day Migration of 750,000 Lines of Code

This paradigm shifted when Jared Sumner utilized Claude's new Dynamic Workflow to port the Bun project from the Zig language to Rust. The scale of the operation was immense, resulting in approximately 750,000 lines of Rust code. What would traditionally take a team of engineers several months to execute was completed from the first commit to the final merge in just 11 days. The precision of the migration was equally striking, with 99.8% of the existing test suite passing upon completion. This result transforms the role of the AI from a coding assistant into an autonomous engineering pipeline capable of executing end-to-end project delivery.

The technical execution relied on orchestration scripts that allowed Claude to spawn and manage dozens or even hundreds of sub-agents within a single session. These sub-agents are specialized, lightweight AI units designed to perform one specific task with high reliability. In the Bun migration, the process began with a foundational workflow where agents mapped every struct field in the Zig codebase to the appropriate Rust lifetime to ensure memory safety. Once the map was established, hundreds of agents were deployed in parallel, each tasked with recreating a specific Zig file in Rust. To prevent the common pitfalls of AI-generated code, the system assigned two dedicated reviewer agents to every single file produced, creating a rigorous internal audit before any code was committed.

Following the initial port, the system entered a refinement loop, iterating on the code until the build and test suites ran without errors. The workflow did not stop at basic functionality; Sumner deployed additional agents to scan the completed codebase overnight, identifying unnecessary data copying and submitting optimized versions via Pull Requests. Because the system saves progress in real-time, the workflow is resilient to interruptions. If a network error occurs or a session times out, the orchestration resumes exactly where it left off. This capability is currently available as a research preview through the Claude Code CLI, the desktop application, and the VS Code extension. Access is granted to users on Max, Team, and Enterprise plans, as well as those utilizing the Claude API. The functionality extends across major cloud AI environments, including Amazon Bedrock, Google Vertex AI, and Microsoft Foundry.

From Single-Prompt Responses to Parallel Agent Orchestration

The fundamental difference between this approach and standard AI interaction is the move from a linear conversation to a dynamic organizational structure. When a developer asks a standard LLM to find a bug in a massive legacy codebase, the model attempts to process the request in a single inference pass. This often leads to hallucinations or the omission of critical edge cases because the model is trying to do everything at once. In contrast, Dynamic Workflow treats a prompt as a project charter. Claude first analyzes the request to build a comprehensive task map, breaking the monolithic goal into hundreds of granular sub-tasks that can be distributed across a fleet of sub-agents.

This architecture introduces a critical layer of adversarial verification. Instead of trusting the first output, the system creates a loop where different agents approach the same problem from opposing angles. One agent proposes a solution, while another is tasked specifically with finding flaws in that logic. They engage in a process of iterative refinement, arguing and correcting each other until the output converges on a verified answer. This internal debate mimics a high-level engineering peer review, achieving a level of accuracy that is nearly impossible for a single-pass inference model to reach.

Crucially, this orchestration happens outside the primary chat interface. By moving the management of sub-agents and state tracking to an external system, Claude avoids the context window degradation that typically occurs in long conversations. The chat window remains a clean command center for the human developer, while the complex logistics of agent coordination happen in the background. Users can trigger this mode by enabling the `ultracode` option in the settings or by explicitly requesting a workflow generation. To prevent runaway token consumption, Claude presents a detailed execution plan for approval before any sub-agents are deployed, ensuring the developer maintains final authority over the process.

While the efficiency gains are massive, the cost structure shifts accordingly. Running hundreds of agents in parallel consumes significantly more tokens than a standard chat session. However, the trade-off is a shift in the unit of value: the developer is no longer paying for a response, but for the completion of a complex engineering milestone. The tension is no longer about whether the AI can write a piece of code, but about how effectively the AI can organize itself to solve a systemic problem.

The era of the AI chatbot is evolving into the era of the AI workforce, where the primary skill is no longer prompting, but orchestration.