AI-Assisted Research Software Engineering: Transforming How We Code

The landscape of research software development is rapidly evolving with the emergence of AI-powered coding assistants, and these tools are increasingly becoming integral to research workflows across our university. AI assistants like GitHub Copilot, Cursor, and complementary services from OpenAI, Anthropic, and Google are demonstrating remarkable capabilities in accelerating code prototyping, automated testing, and real-time error detection. These tools can significantly reduce development time and help researchers implement complex algorithms more efficiently, particularly benefiting graduate and undergraduate students who may be learning new programming languages or working with unfamiliar scientific libraries. However, this technological advancement also presents notable challenges: the volume and speed of AI-generated code can make thorough human verification, validation, and comprehension increasingly difficult, potentially introducing subtle bugs, numerical inaccuracy or security vulnerabilities that may not be immediately apparent. As CRC scientists and engineers actively evaluate these tools, we're observing both their tremendous potential and the critical need for maintaining rigorous software engineering practices.

Recognizing the growing adoption of AI coding assistants among our research community and the need for shared learning around best practices, we're excited to announce the formation of a new informal Community of Practice for AI-Assisted Research Software Engineering. This collaborative initiative will feature monthly working lunch sessions where researchers can share experiences, discuss challenges, and explore effective strategies for integrating AI tools into their research workflows while maintaining code quality and reproducibility standards. We're also launching a dedicated Google Group (rse_ai_asst_cop-list@nd.edu) to facilitate ongoing discussion, resource sharing, and knowledge exchange among participants. Whether you're a seasoned developer curious about AI assistance or a student just beginning to explore these tools, this community will provide a supportive environment to navigate the evolving intersection of artificial intelligence and research software engineering. Stay tuned for our first session announcement (early Aug), and consider joining our mailing list to connect with fellow researchers who are shaping the future of computational research.

Updates on the CRC AI model service OpenWebUI

Here are the recent updates for our university's hosted Open WebUI platform. We have recently added over 20 new GenAI models available on Ollama to our Open WebUI platform. These include Magistral, Devstral, Cogito, Phi4-reasoning, Granite3.2-vision, variants of Qwen3, Llama4, Llama 3.2-Vision and Qwen2.5vl models. We now have over 5 text-embedding models; 15 vision models; and 60 models for use on the platform. The vision models demonstrate excellent performance in various tasks including image captioning, visual question answering, document parsing, and scene analysis of various images like screenshots, photographs, diagrams, charts, scanned pages, receipts, handwritten notes, and AI generated images. An example of the platform's capabilities is shown in a screenshot of the Open WebUI chat interface used in question answering from a photo below. Also, note that you can modify settings, such as your system prompt and more advanced parameters, on the chat control (top right corner), for customized chat responses and retrieval-augmented generation. New users are welcome to sign up and explore the capabilities of our CRC Hosted Open WebUI GenAI platform available at: https://openwebui.crc.nd.edu (on campus or VPN, Notre Dame Google login required). Currently 113 users have signed up on this platform. To support our users, we have also made available an Open WebUI user documentation at https://docs.crc.nd.edu/resources/crcowui.html.If you have any questions, feel free to reach out to us at crcsupport@nd.edu. 

Debugging—figuring out why your code isn’t doing what it’s supposed to—is a skill every developer needs, regardless of experience. Whether you're working in Python, R, MATLAB, Julia, or C++, the same general principles apply. And while the basics haven’t changed much, newer tools (including AI-based ones) can now lend a hand in useful ways.

1. Use the Debugger

If you’re not already using your IDE’s debugger, start. It lets you pause your program, check the state of your variables, and step through the logic line by line. Tools like VS Code, PyCharm, MATLAB, and Julia’s Debugger.jl make this process a lot easier. And if you’re stuck interpreting what you’re seeing, you can even ask an AI assistant to help make sense of it.

2. Log What’s Happening

Logging is essential for understanding how your code behaves over time, especially in longer or more complex runs. Use proper logging libraries—not just print statements—so you can adjust verbosity, filter messages, and write to files.

3. Insert Print Statements

Sometimes you just need to drop in a few print() or disp() calls and see what’s going on. This is especially handy when you’re writing small scripts or working in environments where setting up a logger feels like overkill.

4. Isolate the Problem

If you're facing a mysterious bug, don’t try to fix the whole program at once. Narrow things down. Run individual functions, simplify your inputs, or break things into smaller chunks. If a function is getting too big to manage, try rewriting it into smaller, more testable parts. Many developers use AI tools here to quickly restructure or rephrase logic.

5. Write Unit Tests

Even a few simple unit tests can catch issues before they snowball into bigger problems. Most languages have good testing frameworks—like pytest, unittest, MATLAB’s testing tools, Julia’s Test, or R’s testthat. If you’re not sure how to start, you can describe your function and get AI to sketch out a basic test for it.

6. Pay Attention to Stack Traces

Error messages and stack traces often tell you exactly what went wrong—you just need to take a moment to read them. They’ll show the file, line number, and the chain of function calls that led to the issue.

7. Read the Docs

The documentation usually has the answer. Built-in help systems like help() in Python, ? in Julia and R, or MATLAB’s doc command are great starting points. If the docs are hard to follow, you can ask an AI tool to summarize or provide an example..

8. Tap into Community Knowledge

Sometimes, the fastest fix is just to see how someone else solved the same problem. Stack Overflow, GitHub Issues, MATLAB Central, Julia Discourse, and others are full of practical answers. If you're not sure how to ask the question, you can even get help phrasing it more clearly first.

9. Step Away

When nothing makes sense, take a break. A short walk or a snack can work wonders. Plenty of bugs have been solved minutes after someone stopped actively staring at them.

10. Be Wary of Inherited Code

Working with code you didn’t write? Don’t assume it’s doing what it says. Take time to understand the structure, dependencies, and assumptions. A quick review—sometimes with help from a summarizing tool—can save hours of confusion later.. 

Final Thoughts

There’s no substitute for understanding your code, but you don’t have to tackle every bug alone. Traditional techniques—debuggers, logs, tests, docs—are still your foundation. AI-based tools are just another layer: helpful for breaking problems down, suggesting tests, or explaining things you’re stuck on. Used wisely, they can help you debug faster. 

Student Spotlight: Montana C.

We're kicking off a brand-new monthly feature to spotlight the students behind the innovative research happening here on campus. This month, join us in learning more about Montana.

Name: Montana C.
Department: Chemical and Biomolecular Engineering
Research Summary: The title of my thesis is "Property Predictions using Machine-Learning and Optimization Enhanced Molecular Simulation." The first aim of my research was the development of five new Gaussian process Bayesian optimization (GPBO) methods for accurate and efficient nonlinear model calibration. Nonlinear model calibration is particularly useful for calibrating molecular simulation force field (FF) models. These models allow us to study the physical properties of molecules using computer experiments. For example, molecular systems which can separate hydrofluorocarbon (HFC) refrigerant mixtures are often studied using FF models. As such, the second aim of my research harnesses GP models and data science techniques to systematically generate and optimize a set of Lennard-Jones (LJ) parameters for a FF model which accurately predicts the properties of 13 HFCs. The last aim of my research focuses on applying these techniques to six interesting solvent systems and working with industry collaborators to commercialize this work.
Fun Fact: I organize tournaments for Super Smash Bros Ultimate for the Nintendo Switch for the local South Bend community every Friday.
Favorite Notre Dame activity or tradition: I love the yearly showing of the movie "Rudy" that plays in the stadium.

Every Wednesday and Thursday
2:00 – 3:00 p.m.
812 Flanner Hall (map)

The CRC offers multiple training opportunities for both new and existing users. We periodically provide short courses and other learning opportunities, which are advertised on our website and through email lists. In-person office hours are held every Wednesday and Thursday from 2:00-3:30 p.m. in Flanner Hall, room 812, on a first-come, first-served basis. You can also arrange a Zoom meeting at your convenience by emailing CRCsupport@nd.edu with your availability. We recommend bringing a laptop to in-person sessions.

For more information, please contact CRCsupport@nd.edu.