OpenAI Study Shows Coding Agents Are Accelerating Scientific Software Development

Scientific research increasingly depends on software. From genomics and immunology to statistical modeling and RNA sequencing, researchers rely on specialized tools to analyze data, simulate biological processes, and generate discoveries. Yet many of these tools face a common challenge: they are often developed by small academic teams with limited engineering resources, making long-term maintenance difficult.

A new field report from OpenAI suggests that AI-powered coding agents may help address this challenge. The report examines eight scientific computing projects where coding agents were used to modernize, optimize, rebuild, or maintain research software. According to the findings, the use of AI coding assistants contributed to significant performance improvements, reduced development time, and enabled projects that may otherwise have been impractical due to resource constraints.

The report focuses on projects that used OpenAI’s Codex coding agent in five cases, while three projects combined Codex with Anthropic’s Claude Code. Although the study was published by OpenAI and is based on contributor-written case studies involving its own technology, the findings provide valuable insights into how AI coding tools are being applied in real-world scientific software development.

More importantly, the report highlights a growing trend: coding agents are becoming powerful collaborators for research teams. However, contributors repeatedly emphasized that human expertise, scientific judgment, and rigorous validation remain essential.

The Growing Maintenance Problem in Scientific Software

Scientific software occupies a unique position within the technology ecosystem.

Unlike commercial software products backed by dedicated engineering teams, many research tools are created to support a single study, publication, or grant-funded project. Once the original research is complete, ongoing maintenance often becomes difficult due to limited funding and staffing.

Over time, these projects accumulate technical debt. Build systems become outdated, dependencies break, documentation ages, and performance issues remain unresolved. Researchers may continue relying on the software long after active development has stopped, creating challenges for reproducibility and future innovation.

OpenAI’s report argues that coding agents can help reduce this burden by automating time-consuming engineering tasks that often prevent research software from evolving.

The eight projects highlighted in the report span multiple scientific disciplines, including:

• Genomics
• Immunology
• Statistical computing
• RNA sequencing
• Mutation simulation
• Genome assembly

Across these fields, AI coding agents were used for software modernization, performance optimization, infrastructure improvements, and complete system rewrites.

Three Major Categories of AI-Assisted Development

The projects analyzed in OpenAI’s report generally fell into three categories.

1. Build System and Packaging Modernization

Several projects used coding agents to update legacy infrastructure.

Scientific tools frequently depend on outdated packaging systems and build processes that become difficult to maintain. Modernizing these systems can improve reliability, simplify installation, and ensure long-term compatibility.

2. Performance Optimization

Another major use case involved improving the speed and efficiency of existing software.

Coding agents helped identify bottlenecks, implement optimizations, and test performance improvements against benchmark datasets.

3. Language and Backend Migration

The most ambitious projects involved complete software migrations.

These included porting applications to new programming languages, rebuilding abandoned tools from scratch, and redesigning software to take advantage of modern computing architectures such as GPUs.

The diversity of these projects demonstrates that coding agents are moving beyond simple code generation and increasingly contributing to large-scale engineering efforts.

cyvcf2: Modernizing a Popular Genomics Library

One of the projects featured in the report involved cyvcf2, a widely used Python library for reading genomic variant files.

The project relied on an aging build and packaging system that required modernization. According to contributor Brent Pedersen, coding agents helped replace the legacy setup with a newer and more unified process.

The work improved maintainability and streamlined the development workflow.

However, Pedersen stressed that while coding agents can dramatically increase development speed, scientific software still requires human oversight.

He noted that moving quickly with AI tools is one thing, but advancing scientific software successfully still demands:

• Expert guidance
• Domain understanding
• Technical judgment
• Careful decision-making
• Engineering taste

His comments reflect a recurring theme throughout the report: AI can accelerate implementation, but humans remain responsible for direction and quality.

HI.SIM Achieves a 31% Runtime Reduction

Another project highlighted in the report was HI.SIM, a DNA sequencing read simulator.

Contributor Andrew Ho reported that two largely autonomous optimization efforts using GPT-5.2 and GPT-5.6 resulted in a significant performance improvement.

According to the report, runtime was reduced by 31% across a representative test dataset without changing the simulator’s output.

The achievement is particularly notable because Ho describes himself as neither a genomics expert nor a C programming specialist.

Like many researchers, he could identify performance issues and packaging problems but lacked the specialized expertise required to solve them efficiently.

From his perspective as an end user, the outcome was transformative.

Ho described the experience as “nothing short of magical,” emphasizing how coding agents helped overcome technical challenges that had previously slowed development.

Hifiasm Sees Significant Performance Gains

The report also discusses improvements made to Hifiasm, a tool commonly used for genome assembly from PacBio HiFi sequencing reads.

Contributor Suyash Shringarpure reported that coding agents achieved:

• A 25% runtime reduction on the primary optimization target
• Approximately 15% faster performance on separate human sequencing datasets

According to Shringarpure, the coding agent independently established benchmarking infrastructure and proposed optimization candidates.

However, the process was not fully autonomous.

Human involvement remained essential for:

• Providing profiling data
• Interpreting results
• Guiding optimization strategies
• Preventing repeated failures

The project illustrates how AI can automate portions of performance engineering while still relying on human expertise for decision-making and evaluation.

MHCflurry Migrates from TensorFlow to PyTorch

The report highlights another important maintenance project involving MHCflurry, a tool used to predict protein fragments presented to T cells.

The software originally relied on TensorFlow and Keras. Contributors Alex Rubinsteyn, Sergey Feldman, and Timothy O’Donnell used coding agents to migrate the backend to PyTorch.

A major challenge involved preserving compatibility with previously released model weights.

Successfully maintaining backward compatibility ensured that researchers could continue using existing models without disruption.

The contributors described this type of migration as the kind of labor-intensive maintenance work that often receives little recognition but is critical for the survival of open-source scientific software.

Without such updates, many research tools gradually become obsolete.

bayesm-rs Delivers Major Performance Improvements

One of the report’s most compelling examples involved bayesm-rs, a Rust implementation of statistical models originally provided by the R package bayesm.

Contributors Andrew Bai and Andrew Ho reported impressive performance gains.

The Rust version produced estimates matching the original software within predefined tolerances while achieving:

• 2.3–2.7 times faster execution on a single processor thread
• 4.4–9.5 times faster performance across eight threads

The contributors observed that coding agents performed exceptionally well when working against clear reference implementations.

Tasks involving direct comparisons, established outputs, and measurable benchmarks were often completed quickly and accurately.

However, situations requiring statistical interpretation or judgment remained dependent on human validation.

Where the original software lacked clear guidance, researchers still needed to determine whether outputs were scientifically appropriate.

Rust Rebuilds Enable Previously Impractical Projects

Several additional projects involved software rewrites using Rust.

These projects included:

• rustar-aligner
• svb
• kuva

Perhaps the most ambitious effort was a full recreation of STAR, a widely used RNA-sequencing alignment tool that had lost active maintenance.

Contributor James M. Ferguson noted that coding agents fundamentally changed the economics of software development.

Rewriting a 20,000-line application manually would normally require substantial time and resources.

With coding agents, however, the same effort became achievable through weeks of guided development.

This shift dramatically expands the range of projects that small teams can realistically undertake.

Nevertheless, Ferguson emphasized an important distinction.

Generating code is only part of the process.

Verification remains a separate and often more difficult challenge.

For example, while an AI model might claim that generated plots appear correct, someone still needs to manually review hundreds of outputs before releasing software to the scientific community.

In one case, more than 900 plots required human inspection.

RustQC Consolidates Multiple RNA-Sequencing Tools

Another project highlighted in the report is RustQC, which consolidated 15 separate RNA-sequencing quality-control tools into a unified application.

Contributor Phil Ewels reported substantial efficiency gains.

According to the findings:

• Runtime improved by 60 times
• Disk input/output operations were reduced by 25 times

Companion projects also delivered notable performance increases:

• FastQC-Rust ran seven times faster
• Trim Galore operated three times faster

Importantly, these improvements were achieved while preserving the behavior of the original software.

Maintaining consistency is especially important in scientific computing because researchers depend on reproducible results.

Ewels also raised concerns about the unintended consequences of accelerated software development.

When rebuilding tools becomes easier, multiple competing versions may emerge.

If those versions begin producing different outputs, scientific communities risk fragmentation and reduced reproducibility.

As Ewels explained:

“The technology is the easy part. Stewardship is the open question.”

His observation highlights one of the central governance challenges facing AI-assisted software development.

HelixForge Delivers Massive GPU-Based Speed Improvements

Among the most dramatic examples in the report is HelixForge, a GPU-native redesign of the mutation simulation tool BAMSurgeon.

Contributors Mamad Ahangari, Varun Goyal, and Hassan Masoudi reported that the new implementation achieved approximately 60 times faster runtime on benchmarks involving real human datasets.

Beyond raw speed improvements, the project also delivered quality enhancements.

According to the contributors, HelixForge:

• Generated mutation frequencies closer to requested targets
• Fixed several bugs present in the original software
• Eliminated artifacts created by earlier implementations

The project demonstrates how coding agents can support not only maintenance and optimization efforts but also major architectural redesigns.

By helping researchers leverage GPU computing, AI coding tools may enable scientific applications that were previously too resource-intensive to pursue.

Verification Remains the Biggest Bottleneck

Despite the impressive performance gains reported across all eight projects, a consistent message emerges throughout OpenAI’s findings.

The primary challenge is no longer generating code.

The real bottleneck is verification.

Contributors repeatedly reported situations where coding agents confidently produced incorrect solutions.

In many cases, the code appeared plausible but contained subtle flaws that only careful testing could reveal.

As a result, successful projects invested heavily in validation methods such as:

• Exact output comparisons
• Benchmark testing
• Parity checks against established tools
• Simulated datasets with known answers
• Regression testing frameworks

The coding agents often produced useful first drafts quickly, but ensuring scientific accuracy required substantial human involvement.

This distinction is critical.

In scientific software, correctness matters more than speed.

A highly optimized program that produces inaccurate results can undermine entire research efforts.

Human Expertise Remains Essential

One of the strongest conclusions from the report is that coding agents function best as collaborators rather than replacements.

Across all projects, researchers remained responsible for:

• Defining goals
• Designing experiments
• Evaluating outputs
• Interpreting scientific significance
• Approving final implementations

AI systems excelled at executing clearly defined tasks, especially when measurable benchmarks existed.

However, they struggled when projects required domain-specific reasoning, scientific interpretation, or judgment calls.

This finding aligns with broader trends in AI-assisted software development.

The most successful outcomes typically occur when human experts combine domain knowledge with AI-generated implementation support.

The Double-Edged Sword of Lower Development Costs

The report also highlights an important tradeoff.

Lower engineering costs create new opportunities.

Small research teams can now undertake ambitious projects that previously required dedicated software engineers or large grant budgets.

Maintenance work becomes more accessible.

Legacy software can be modernized more efficiently.

Performance bottlenecks can be addressed more quickly.

Yet the same forces introduce new risks.

If multiple groups independently rebuild the same tool, the scientific ecosystem may become fragmented.

Different versions could produce slightly different outputs, making results harder to compare across institutions and studies.

To address this concern, several projects ensured their improvements flowed back into existing community-maintained software.

For example:

• Changes to MHCflurry were contributed upstream
• Improvements to cyvcf2 were integrated into the original project
• rustar-aligner transitioned to new community stewardship after replacing abandoned software

These efforts help preserve consistency while still benefiting from AI-assisted development.

The Future of AI in Scientific Software Development

OpenAI’s field report offers a detailed look at how coding agents are already influencing scientific computing.

Across genomics, immunology, statistical modeling, RNA sequencing, and mutation simulation, researchers used AI tools to modernize infrastructure, optimize performance, migrate software platforms, and rebuild abandoned systems.

The reported results include:

• 31% runtime reductions in DNA sequencing simulation
• 25% performance gains in genome assembly
• Up to 9.5 times faster statistical modeling
• 60 times faster RNA quality-control processing
• Approximately 60 times faster mutation simulation on GPUs

While these achievements demonstrate the growing capabilities of coding agents, the report’s most important lesson may be organizational rather than technical.

The central challenge is no longer whether AI can generate code.

The challenge is determining who will validate, maintain, govern, and steward the resulting software over time.

OpenAI’s findings point toward a clear strategy for research teams: establish ownership and long-term maintenance plans before deploying AI-generated software. Coding agents can dramatically accelerate development, but sustainable scientific software still depends on human expertise, rigorous validation, and responsible stewardship.