Agentic AI for Scientific Software Development: Faster Engineering, Not Automated Science

Artificial intelligence will not replace research software engineers. But it is already changing how they work.

This was also the conclusion of Robert Speck’s recent JuRSE blog post,“Will AI replace research software engineers?” The answer is no, but the important follow-up question is: if AI does not replace RSEs, how should we use it responsibly in scientific software development?

The useful shift is not simply that AI can generate code snippets. We have had code completion, search engines, and chat-based assistants for some time. The bigger change is that agentic AI tools can now work in the context of an existing repository, inspect files, edit code, run tests, summarize changes, and return reviewable diffs. The interaction moves from asking for isolated suggestions to delegating bounded software tasks under human supervision.

That distinction matters for research software. Scientific software is not “just software”. It encodes assumptions, numerical methods, data conventions, workflows, and domain knowledge. Its outputs may become part of scientific evidence. Therefore, the central question is not whether AI can write code. It is whether we can integrate AI into RSE practice in a way that is reproducible, inspectable, and trustworthy. This connects directly to established work on FAIR principles for research software and practical reproducibility guidance such as The Turing Way.

A useful mental model is to draw a trust boundary. Tasks such as formatting, documentation, test scaffolding, interface cleanup, simple refactoring, or boilerplate generation are often good candidates for delegation. They still need review, but the scientific risk is limited. Tasks involving the choice of numerical methods, algorithmic interpretation, scientific models, or conclusions require much stronger human control. AI can help explore, implement, and test such changes, but it must not become the source of scientific judgement.

In climate and Earth system modelling, recent work on the FESOM2 ocean model provides a striking example of this boundary in practice. In the preprint “An Ocean Model Ported by a Large Language Model: Experience and Lessons from FESOM2”, Koldunov et al. describe the LLM-assisted porting of a production ocean–sea-ice model from Fortran to C and then to C++/Kokkos. The important lesson is not simply that an AI system helped translate a large codebase. The key point is how carefully the work was constrained: domain experts directed the process, the translation was staged, the assistant was instructed not to “improve” the source, and each stage had explicit validation criteria. This is a strong example of agentic AI used appropriately: not as an autonomous scientist, but as a tireless engineering assistant working inside a disciplined scientific validation workflow.

Responsible AI for RSE is not “vibe coding”. In fact, agentic AI makes disciplined RSE practices more important, not less. Good prompts are easier to write when the problem is well understood, and generated changes are easier to review when a project has tests, documentation, continuous integration, and clear architecture. Recent work on AI and research software engineering makes the same point: Farshidi et al. distinguish between software engineering maturity and AI integration, leading to modes such as exploratory coding, vibe coding, traditional RSE, and AI-assisted RSE. Their key message is important: more AI does not automatically mean better research software. AI can amplify disciplined workflows, but it can also compensate for missing structure in ways that create risk.

A practical limitation is the finite context window of current AI models. In large or long-lived scientific software projects, an agent may not be able to consider the entire repository, its documentation, previous decisions, and all relevant test results at once. Even when tools retrieve files dynamically or summarize earlier interactions, important assumptions can be omitted or compressed. Effective AI-assisted RSE therefore also requires active context management: identifying the relevant parts of the codebase, documenting decisions, splitting work into bounded tasks, and verifying that the agent has not overlooked dependencies outside its immediate working context.

The same message appears in the practical recommendations by Bridgeford et al.,“Ten Simple Rules for AI-Assisted Coding in Science”: responsible AI-assisted scientific coding requires preparation, context, testing, and review. The practical lesson is simple: do not start by asking an AI agent to “improve my code”. Start by asking it to inspect the repository, summarize relevant files, identify assumptions, and propose a plan. Then delegate small, reviewable tasks, ask for tests before or alongside implementation, keep diffs small, run independent checks, and review not only whether the code passes, but whether the behavior makes sense for the scientific problem.

Agentic AI can be valuable for learning and onboarding. It can explain unfamiliar code, compare implementation approaches, generate small examples, and help newcomers ask better questions. But there is a mentoring dilemma. If experienced researchers use AI to do all easy tasks themselves, students and new colleagues may lose the chance to learn the foundations. And if nobody learns the hard parts, nobody will be able to review AI-generated work. RSE teams should therefore treat AI not only as a productivity tool, but also as something that changes training, supervision, and knowledge transfer.

For institutions, the technical question is only part of the story. Governance matters: Which AI tools are approved for which software, data, and confidentiality levels? What about unpublished results, personal data, licensing, third-party code, provider terms, and documentation for traceability? These questions are still evolving, but they cannot be ignored. This is also why institutional and open solutions matter: within Helmholtz,BLABLADOR provides access to LLMs through a chat interface and API, and, combined with open agentic coding tools such as Hermes Agent or OpenCode, may support AI-assisted RSE workflows that better fit institutional requirements for data protection, reproducibility, transparency, and local governance.

So, will agentic AI replace research software engineers? No. But it will change what good research software engineering looks like. The RSE role becomes less about manually producing every line of code and more about framing problems, managing context, designing tests, reviewing changes, validating results, and preserving scientific accountability.

Agentic AI can accelerate the engineering layer of scientific software development. Scientific judgement remains a human responsibility.

Further reading

• Robert Speck,“Will AI replace research software engineers?”
• Nikolay V. Koldunov et al.,“An Ocean Model Ported by a Large Language Model: Experience and Lessons from FESOM2”
• Siamak Farshidi et al.,“Advancing research software engineering with AI: a research framework”
• Eric W. Bridgeford et al.,“Ten Simple Rules for AI-Assisted Coding in Science”
• FAIR4RS Working Group,“FAIR Principles for Research Software”
• The Turing Way, Guide for Reproducible Research

Written By: Lars Hoffmann, Jülich Supercomputing Centre (JSC)