# Meta's VR Codebase Nobody Wanted to Touch — Until This

## Executive summary

This talk explores advanced strategies for modernizing legacy (brownfield) codebases using AI agents. Speakers argue that true modernization requires reverse-engineering the underlying business specifications and entity models, rather than simply performing 'lift-and-shift' migrations. Key architectural advice focuses on decoupling the system by ensuring the development process is not overly dependent on a single AI provider, model, or hardware environment, exemplified by the use of an MCP server to parallelize work across multiple on-demand environments.

## Key takeaways

- Brownfield Code as a City, Not a Ball of Mud: Legacy systems should be viewed as complex, functioning cities that have evolved over time, rather than a 'ball of mud.' The goal is to evolve the system into a more understandable, buildable structure, allowing for clear paths of development.
- Modernization Requires Specification Extraction: True software modernization involves reverse-engineering the use case and entity model from existing code, tests, and documentation, and then generating new code based on that specification. Simply translating an old language (e.g., COBOL to Java) is considered 'lift and shift' and is insufficient.
- Decoupling the AI Stack (The Three Boxes): Architects must be wary of dependency on three uncontrolled components: the **harness** (interface), the **model host**, and the **model** itself. Building a digital product that can quickly switch between providers is critical for resilience.
- Parallelizing Refactoring with Agents: AI agents can be taught specific refactoring patterns and then used to find similar patterns across a codebase, allowing multiple agents to work in parallel. This approach was used to move VR development off a single, powerful Windows machine.

## Technical details

- Brownfield Code Architecture: Brownfield systems are complex, successful, and evolve over time, functioning like a city with clear paths and less-maintained areas.
- Software Modernization Process: The process involves extracting use cases and entity models from existing artifacts (code, tests, documentation) and having the business review the specification before generating new code.
- AI Dependency Architecture: A robust system must decouple its workflow from specific providers by ensuring the **harness** (interface) can be swapped (e.g., switching from Claude Code to an open API) without rewriting the entire product.
- MCP Server Implementation: To overcome hardware constraints (like being limited to one powerful PC for VR), an MCP server was implemented. This server acted as a bridge, providing models with standardized world state data (textures, world structure) so that work could be parallelized across multiple on-demand environments.

## Practical implications

- When modernizing legacy code, prioritize extracting the business specification (use case/entity model) over direct language translation.
- Design AI-native workflows with interchangeable components (harnesses) to mitigate vendor lock-in and single-point-of-failure risks.
- Use specialized servers (like an MCP server) to standardize and decouple complex, stateful environments, enabling parallel agent work.
- Treat code evolution as a continuous process of architectural improvement, not just bug fixing.

## Topics

AI-native development, Brownfield code, Software Modernization, Agent Workflows, System Architecture, Refactoring, AI DevCon NYC 2026, Tessl

Source: https://www.youtube.com/watch?v=UVOkQyeY16M