Genomic Code Rewritten: How an AI Agent Modernized 20,000 Lines of Legacy Code and Accelerated Processes by 60x

The implementation of AI agents has not only modernized outdated scientific software but also significantly accelerated critical processes in genomic research. For instance, RNA-sequencing quality control was sped up by 60 times, and rewriting 20,000 lines of genomic aligner code to a new language achieved 99.8% equivalence. Synthetic genome generation, which previously took 1,610 seconds, now completes in 27 seconds.

Scientific computing is plagued by a chronic code maintenance issue, dating back decades. Often, this is the result of small academic teams or even a single PhD student developing tools for a specific paper, with limited time, funding, or incentive for durable engineering. This leads to 74% of scripts failing in a clean environment, and 57% of tools failing to install according to their own instructions. Errors in such code can lead to incorrect scientific conclusions and even retraction of publications. This problem, long considered inevitable, now has a solution.

The Reality of the Problem: The Scientific Software Maintenance Crisis

A significant portion of the computational infrastructure underlying modern genomics, biology, and climate science was built by small academic groups. Often, it was a PhD student developing tools for a single paper, with minimal resources and no focus on long-term support. This led to many programs becoming obsolete, fragile, and difficult to reproduce.

Large-scale studies confirm this issue: over 9,000 published R scripts showed that 74% failed to run in a clean environment. A separate review of 98 genomic tools revealed that 57% broke when following their own documentation. In the worst cases, this is not merely an inconvenience but a cause of errors in analysis, leading to the retraction of scientific papers in leading journals such as Nature Medicine and Science.

The Path to AI Agents: Addressing the Shortage of Engineering Talent

Traditional methods of supporting and updating scientific code, which require significant engineering resources, proved ineffective. Scientists, whose primary task is research, lacked the capacity or incentive to engage in routine engineering work. This is where AI agents offered a radically different solution: they can absorb this engineering burden, freeing scientists for their core activities.

Instead of searching for and hiring expensive specialists to rewrite legacy code, companies began to use AI agents. These systems are capable of not just automating individual steps but also performing complex tasks such as modernization, dependency migration, rewriting code in new languages, and even creating GPU-optimized solutions from scratch.

How AI Agents for Scientific Code Were Designed

AI agents were designed as multifunctional systems capable of solving a wide range of tasks, from routine packaging fixes to complete code rewrites. They were required not only to generate new code but also to interact with each other in an "adversarial pairing" mode. In this mode, one agent acted as a developer, the other as a reviewer, allowing the detection of errors that each agent might miss individually.

However, despite high autonomy, the human role remained critically important. Agents could effectively perform tasks according to given specifications, but defining what constitutes a "correct" result and building the infrastructure for its verification always remained with the scientist. Without this validation mechanism, the agent could "rationalize" deviations from the expected result, considering them scientifically valid, even if they were actually errors.

Implementation: From Individual Tasks to Comprehensive Rewrites

The implementation of AI agents began with solving specific, well-defined tasks where the effect was obvious and the risks minimal. For example, agents were used to accelerate RNA-sequencing quality control. The RustQC project rewrote 15 separate post-alignment tools into a single Rust binary. This reduced execution time from 15 hours 34 minutes to 14 minutes 54 seconds, decreasing disk I/O by 25 times.

Gradually, agents took on more complex tasks, such as the complete rewriting of 20,000 lines of legacy C/C++ genomic aligner STAR into Rust. This project, rustar-aligner, achieved 99.8% equivalence with the original. An important step in the implementation was the use of agents in "adversarial pairing" mode, where two agents, each with their strengths, alternately acted as developer and reviewer. This allowed the identification and correction of classes of errors that one agent might miss.

Results: Figures and Opportunities

The economic impact of using AI agents is immense. It is estimated that preventing 25-50% of software installation failures can save between 80 and 330 researcher-hours per 1,000 reuse attempts, equivalent to $6,000 – $49,000. On a scale of 100 packages, this extends to $600,000 – $4.9 million. For ongoing maintenance, such as the NumPy library, agents can save approximately 650 hours per year, amounting to $49,000 – $98,000 annually.

How to Implement This in Your Business: Focus on Validation

The key takeaway from these case studies is that AI agents can significantly accelerate code development and modernization, but their effectiveness directly depends on the quality of validation. If your business faces the need to update legacy systems or optimize complex computational processes, AI agents can be a powerful tool. Here's how to begin:

• Define clear success metrics. Agents cannot determine "correctness" themselves. You need to establish in advance how you will measure the success and accuracy of their work.
• Build a robust validation system. This could be a set of tests, reference data, or parallel comparison with existing systems. Validation is the primary human task when working with AI agents.
• Start with small, well-defined tasks. Gradually increase complexity, ensuring the agent's reliability at each stage.
• Utilize "adversarial pairing." If possible, involve multiple AI agents or a combination of an agent and a human for mutual code review.
• Be prepared for agents to "drift." They may deviate from initial instructions in an attempt to complete a task. Human oversight is necessary to guide them back on track.

If this case sounds like what's happening in your company, our manager can help: he'll analyze your business and niche for free and point out where an AI agent would bring a real result in your case. Message the manager