AI Coding Tools Are Learning Older Programming Languages

Artificial intelligence coding assistants have become increasingly useful for writing functions, explaining unfamiliar code and helping developers solve programming problems. However, their usefulness has not been equal across every programming language.

Modern languages such as Python and JavaScript have extensive online documentation, tutorials, public repositories and examples. Older languages may have less readily available training material, even when they remain essential to financial systems, scientific computing and other critical applications.

That gap is the focus of a new research update published by OpenAI on October 19, 2026. The company reported improvements in AI-assisted software development involving languages including COBOL, Fortran, OCaml and Visual Basic.

The research matters because many organisations depend on software written years or decades ago. Modernising those systems is not simply a matter of translating one programming language into another. Engineers must understand how the existing software behaves, preserve important business rules and demonstrate that the replacement continues to work correctly.

Read OpenAI’s research announcement on coding in low-resource programming languages.

Why older programming languages still matter

The technology industry frequently discusses new frameworks, cloud platforms and AI development tools. Yet important parts of the digital economy continue to depend on established software.

COBOL, for example, remains relevant in banking and transaction-processing environments. Fortran continues to be used in scientific and numerical computing, where performance and decades of established code can make a rewrite a substantial undertaking.

These systems may support essential operations, including processing financial records, calculating numerical results or managing established business workflows. Replacing them can involve more than reproducing the visible features of an application.

A legacy system may contain years of accumulated business rules, special-case handling and assumptions that are not fully documented. Some of that knowledge may exist only in the code itself or in the experience of engineers who have maintained it.

This creates a difficult problem for organisations: they need to improve old software, but changing it without understanding its behaviour can introduce serious errors.

What OpenAI's latest research reports

OpenAI introduced two evaluations to measure different aspects of AI coding capability.

The first, called MultiLangBench, tests whether a model can build a SQLite-compatible database engine in different programming languages. The task requires more than producing a short code snippet. It involves organising a codebase, managing state, handling errors and adding functionality while preserving existing behaviour.

OpenAI reported that GPT-6 Astra achieved an average test pass rate of 87.4% across 20 languages at maximum reasoning effort, compared with 26.8% for GPT-5.6 Sol in the reported evaluation. The company also reported improvements from GPT-6 Luna, which achieved a 40.3% average pass rate in the same evaluation at maximum reasoning effort.

The second evaluation examines COBOL migration. It tests whether AI can convert existing COBOL programs into languages such as C++, Java, Kotlin, Python or Rust while preserving their behaviour.

According to OpenAI, GPT-6.1 Sol achieved 86.6% accuracy at low reasoning effort in this evaluation, compared with 5.4% for GPT-5.6 Sol at the same setting. OpenAI reported that accuracy reached 97.9% at higher reasoning effort.

These are results from the company's stated evaluations, not proof that every real-world codebase can be migrated with the same accuracy. The benchmark setup, selected tasks and evaluation criteria all influence what the results demonstrate.

The important development is that AI coding systems are being evaluated on more demanding tasks than generating isolated snippets. They are being tested on building software across multiple languages and preserving the behaviour of existing applications.

Why code migration is harder than translation

Consider a financial application that calculates interest, processes payments or reconciles transactions. A migration tool might translate its code into a newer language and produce a program that runs successfully.

That alone does not prove the migration is correct.

Suppose the original program handles decimal values using a specific rounding rule. If the replacement uses a different rule, the new application may produce different financial results even though it compiles and appears to function normally.

Other differences can involve date handling, missing records, sorting, error conditions and the order in which operations occur.

A successful migration must preserve the behaviour that matters to the business, not merely produce syntactically valid code.

For this reason, engineering teams should combine AI assistance with:

• Automated regression tests that compare the new implementation against established expected results.
• Representative test data covering ordinary operations, unusual inputs and historical edge cases.
• Code review by engineers familiar with the system's purpose and constraints.
• Parallel validation, where practical, to compare outputs from the old and new systems.
• Rollback procedures so that a deployment can be reversed if unexpected problems appear.

OpenAI's research specifically discusses behaviour-preserving evaluation as a way to assess migration quality. That is a useful direction because software modernisation must be judged by the correctness of the result, not simply by how quickly code is generated.

Can AI make legacy software easier to maintain?

Potentially, yes. AI coding assistants can help developers explore unfamiliar repositories, identify related functions, explain code paths and propose changes. They may also help generate tests, document existing behaviour and create candidate implementations in a newer language.

These capabilities can reduce some of the manual work involved in understanding a large codebase.

For example, a developer maintaining an old inventory application could ask an AI tool to explain how stock adjustments are processed, identify functions that modify quantities and suggest tests for negative inventory values. The engineer would still need to verify the explanation, check the relevant code and determine which business rules are correct.

The distinction is important: AI can help make software easier to understand, but its explanations are not automatically authoritative documentation.

Teams should treat generated explanations and proposed code as working material to review and test. This is particularly important when software handles money, sensitive information or operations where a defect could have significant consequences.

AjiNova has explored a related issue in its article, “Ford Fired Its Veteran Engineers for AI. Now It's Quietly Hiring Them All Back.”. The broader engineering lesson is that automation can support technical work, but it does not eliminate the value of domain expertise and human judgement.

What this means for software teams in Africa

For businesses in Kenya and across Africa, legacy software modernisation is not only a concern for large international banks. Organisations may rely on older accounting systems, enterprise databases, government applications or custom-built platforms that have evolved over many years.

Replacing these systems can be expensive and risky. In some cases, a gradual migration may be more practical than rebuilding an entire application at once.

AI tools could assist with parts of that process, including code documentation, test generation, dependency analysis and the development of replacement modules. They may also help smaller engineering teams investigate systems that lack complete documentation.

However, the economics depend on the specific project. Organisations must account for model usage, engineering review, testing infrastructure, data protection and the cost of fixing errors. A tool that generates code quickly may still require substantial human effort before the code is safe to deploy.

There is also an opportunity to combine AI assistance with more efficient system design. AjiNova's coverage of a Nairobi startup experimenting with AI on low-cost hardware illustrates another important engineering question: how can developers deliver useful technology while controlling computing costs?

The same principle applies to coding assistants. The goal should be to improve the productivity and reliability of the entire development process, not simply to maximise the amount of AI-generated code.

Security and governance still matter

Older applications can contain sensitive business logic, customer records and operational details. Sending source code to an external AI service may create confidentiality or compliance concerns, depending on the organisation's contracts, settings and regulatory obligations.

Before adopting an AI coding tool, teams should establish which code and data may be submitted, who can access the outputs, how generated changes are reviewed and how credentials are protected.

AI-generated code should also be checked for security weaknesses, unsafe dependencies and unintended changes to access controls. A migration that passes functional tests can still introduce a vulnerability if security requirements are not tested separately.

For higher-risk systems, organisations should define explicit approval requirements and avoid allowing unreviewed AI-generated changes to reach production automatically.

What developers should do now

Developers interested in AI-assisted modernisation can start with a small, well-understood component rather than attempting to migrate an entire critical system.

A practical approach is to document the component's expected behaviour, build a baseline test suite, ask an AI tool to analyse or modify a copy of the code, and compare the results against the baseline. Record the time saved, the number of errors found during review and the amount of additional work required.

That evidence will help a team decide whether the technology is useful for its particular workload.

OpenAI's announcement also points developers toward its published MultiLangBench evaluation and test suite, which provides further details about how the company measured performance across programming languages.

The bigger picture: modernisation, not just code generation

The most important question for AI coding tools is not whether they can produce code that looks convincing. It is whether they can help engineering teams build and maintain software that behaves correctly, remains secure and can be supported over time.

Improved performance on older programming languages could make some modernisation tasks more accessible. It could also help developers understand unfamiliar systems and test proposed changes more efficiently.

But real applications contain business rules, dependencies and operational constraints that cannot be captured by a single benchmark score.

AI can be a valuable assistant in that work. The strongest results will come when model capabilities are combined with reliable tests, experienced engineers and a clear understanding of what the software must do.

References

1. OpenAI — Advancing Coding in Low-Resource Programming Languages — October 19, 2026. Primary source for the reported benchmark and COBOL migration results.
2. AjiNova — Ford's experience with AI and veteran engineering expertise.
3. AjiNova — A Nairobi startup running AI on low-cost hardware.
4. OpenAI Research — additional research publications and evaluation work.