Agentic AI tools can help implement, revise, and test research software.
Their use also makes it important to define what the software should do,
decide which changes are valuable, and establish evidence that the results
meet scientific and technical requirements. This topic explores how to
organize that work so a project’s development remains understandable and
reviewable as the pace of implementation increases.
You will set up coding agents and their project instructions, turn research
needs into software specifications, and express expected behavior through
behavior-driven development (BDD) scenarios. You will combine unit,
integration, acceptance, and regression tests with checks such as Ruff and
complexipy, and explore property-based and mutation testing to assess
different aspects of correctness and test effectiveness.
Drawing on product-owner and Scrum Master perspectives, you will practice
prioritizing a backlog, defining completion criteria, and working in short
cycles of implementation, review, and refactoring. You will also maintain
concise agent instructions, design decisions, and handover notes as the
project changes, use git-ai to track AI contributions, and examine copyright,
licensing, attribution, and research-software disclosure.
Why This Matters
Producing code is one part of developing useful research software.
Researchers also need to understand its assumptions, check its scientific
behavior, and leave a project that collaborators can maintain. When
implementation moves quickly, review, documentation, and consolidation need
an explicit place in the development process.
Specifications and independent checks help keep implementation connected to
research intent. Small, reviewable changes and short feedback cycles make
it easier to notice misunderstandings and revise direction. Automated
quality checks can flag selected code problems and excessive complexity,
while scientific validation and design review remain part of human
oversight.
Questions We Can Explore Together
- How can I configure a coding agent’s environment, permissions, and project
instructions so its work stays within a clear scope?
- How can I turn a research need into a specification and BDD scenarios with
meaningful acceptance criteria?
- How can I check that tests challenge an implementation’s assumptions,
including when AI helps write both the code and the tests?
- What can Ruff, complexipy, and different kinds of automated tests tell me,
and what still needs scientific or human review?
- How can I prioritize work and balance new features with review,
refactoring, and consolidation as a project changes quickly?
- Which instructions, decisions, and handover notes should I retain, and how
can I keep them current without accumulating conflicting documentation?
- What does AI contribution tracking reveal, and how does it relate to
attribution, copyright, licensing, and disclosure when sharing research
software?
Supported Approaches
Scientific Python
Apply specifications, tests, and code review to data analysis, scientific libraries, and research software written in Python. Familiarity with small Python programs is required for this approach.
HTML and CSS
Apply the same practices to research websites: structure content, review layouts, and check that generated pages communicate clearly. Website-focused events may also use Markdown and Hugo; consult the event page for its particular tools and requirements.
iBOTS
