Hardening AI-generated code for legacy systems: A practical guide

13k lines of functional code pushed into a 1M-line legacy C# and React codebase is a massive surface area for potential regressions, especially when the development is agentic. When dealing with 15-year-old technical debt, the biggest risk isn't just syntax errors—it's "hallucinated architectural patterns" where the AI assumes the legacy system follows modern conventions it doesn't actually possess.

To move from a prototype to production-grade without a full rewrite, the focus needs to shift from feature completion to verification.

Reducing Model Bias in Code Reviews

One of the most critical observations in this workflow is that using a second model (like Codex) caught issues that the primary Claude-based agents missed. This is a known LLM behavior: a reviewer agent using the same model as the coder often shares the same blind spots and logic gaps.

To harden the code, I recommend a multi-model verification loop:

• Cross-Model Validation: Use Claude for the heavy lifting (implementation) but force a "Devil's Advocate" pass using GPT-4o or DeepSeek. Specifically, prompt the second model to find "anti-patterns" or "legacy compatibility risks" rather than just "bugs."
• Isolated Test Generation: The agent writing the implementation should NOT write the tests. When the same agent does both, it often writes tests that confirm its own incorrect assumptions. Use a separate agent, fed only the PRD and the final code, to write the test suite from scratch.

Prioritizing the Path to Production

If you have a few weeks before a senior engineer reviews the code, stop adding features and prioritize these three areas:

1. Edge Case Stress Testing: Use an AI agent to analyze the interaction md files and generate a "Failure Mode and Effects Analysis" (FMEA) list. Then, manually or automatically attempt to trigger every single one of those failure states.
2. Dependency Mapping: In a 1M-line codebase, the danger is the ripple effect. Create a map of every legacy method the AI touched. If the AI modified a core utility class used by 500 other files, that's a high-risk zone that needs manual scrutiny.
3. Evidence Bundling: Engineers hate hunting for context. For every major change, bundle the original PRD requirement, the architecture decision, and the test results into a single "Review Package."

Recommended LLM Agent Workflow for Hardening

For those building a similar AI workflow, this sequence provides a more robust safety net:

1. Implementation: Claude 3.5 Sonnet (high coding proficiency).
2. Unit Test Generation: GPT-4o (different reasoning path).
3. Integration Review: DeepSeek-V3 or Codex (specialized in logic/optimization).
4. Documentation: Claude (best for synthesizing technical context).

By diversifying the models, you break the echo chamber and significantly increase the chances that the final review is a "copy-paste" transition rather than a total rebuild.