Responsible AI Use, Validation, and Reproducibility in Bioinformatics

Kelly Sovacool, PhD

Bioinformatics Software Engineer

CCR Collaborative Bioinformatics Resource

Oct 14, 2026

Important

This presentation was created before the directive to use the term “Super Intelligence (SI)” in place of “Artificial Intelligence (AI)”.

Always refer to the official NIH AI Hub for the most up-to-date policy information.

Goals for this talk

  • Provide background information on AI for Bioinformatics.
  • Cover the NIH Responsible AI Policy.
  • Equip you with practical tips for minimizing the risks of using LLMs & agents for bioinformatics.

Take-home message

By the end, you should feel empowered with the knowledge to use agentic LLMs proficiently for bioinformatics, without compromising the quality of your science.

Bioinformatics is central to biomedical research

Audience roles: bioinformatician, computational biologist, data analyst, research software engineer – anyone who writes code to analyze biological data.

Academic Definition of Generative AI

Agentic LLMs have transformed software development

Agentic LLMs can accelerate bioinformatics

We can write code faster than ever before

generate new code, troubleshoot bugs, search the web, write tests, execute code

We can write bad code faster, too

unreproducible work, incorrect methods, bugs, inefficiencies, unreadable code, lack of transparency, security vulnerabilities, malware, destructive agent actions

NIH Responsible AI Policy

NIH AI Use Checklist

Stop and Reconsider If:

  • You cannot verify the output
  • You cannot explain or justify the result
  • The task involves high-stakes decisions without expert review

1. Confirm the Use is Appropriate

  • Can you clearly state what you need, your audience (e.g., internal, external), and why AI helps?
  • Do you have the time and expertise to review and adapt the output?
  • Are you using a federally approved or authorized tool?

2. Define the Human-AI Roles

  • What task is the AI performing (e.g., drafting, summarizing, classifying)?
  • What decisions will you make (vs. the AI)?
  • Are you prepared to be accountable for how outputs are used?

3. Project Data and Outputs

  • Does your input data include clinical, sensitive, identifiable, or restricted information?
  • Is that data allowed in the tool you are using (e.g., consistent with consent, IRB decision, agreements)?
  • Are you sharing only the minimum data necessary?
  • Do the outputs create new sensitivity, intellectual property, or reuse risks?

4. Verify Outputs

  • Have you checked the facts, numbers, and citations?
  • Have you tested outputs for errors, bias, or omissions?
  • Would you be comfortable defending this output if questioned?

5. Be Transparent About AI Use

  • Will others know AI was used?
  • Have you documented how outputs were generated (e.g., prompts used)?
  • Have you avoided presenting AI output as authoritative without review?

Human in the loop

Human in driving the loop

A better way: humans judiciously use agents when appropriate to support human-driven tasks.

Bioinformaticians design, develop, and execute code

Design

 

  • Read scientific papers, software documentation, and forums.
  • Plan how to analyze data to answer a scientific question.
  • Decide how new code will accomplish the analysis plan.

Develop

 

  • Write new scripts, packages, and command line tools to accomplish the analysis plan.
  • Write tests to validate the code performs as expected.
  • Document how the code works and how it is used to produce results.

Execute

 

  • Obtain the data from the study/experiment.
  • Install necessary software dependencies.
  • Run the code on the data and evaluate the results.

 

How can agents assist us in bioinformatics tasks?

Treat agents like just another tool in your toolbox.

Practical tips for responsible agent use

  Follow reproducible practices

  Review, test, and validate all code

  Document everything

Reproducibility is essential for science

Yourself ➡️ Future you ➡️ Your collaborators ➡️ Peers in your field

  • Can each of the above people run your code on the same dataset and get the same results?
  • How difficult would it be for each of them to reproduce your results?

You are your own most important collaborator

Reproducible practices for responsible AI use

Organize your projects

  • One project per directory.
  • Keep data, code, and outputs in separate subdirectories.
  • Data is read-only; outputs should only be written by the code.
file system tree
/data/$USER/projects
├── my-rnaseq-project
│   ├── AGENTS.md
│   ├── data/
│   ├── docs/
│   ├── README.md
│   ├── results/
│   ├── scripts/
│   └── tests/
└── r-dataviz-explorer
    ├── references/
    ├── scripts/
    ├── SKILL.md
    └── tests/

Reproducible practices for responsible AI use

Organize your projects

  • One project per directory.
  • Keep data, code, and outputs in separate subdirectories.
  • Data is read-only; outputs should only be written by the code.

Version control & backup with git & GitHub

  • Create a git repository for each project and upload it to GitHub.
  • Commit meaningful code changes and sync with GitHub frequently.
file system tree
/data/$USER/projects
├── my-rnaseq-project
│   ├── AGENTS.md
│   ├── data/
│   ├── docs/
│   ├── README.md
│   ├── results/
│   ├── scripts/
│   └── tests/
└── r-dataviz-explorer
    ├── references/
    ├── scripts/
    ├── SKILL.md
    └── tests/

Reproducible practices for responsible AI use

Organize your projects

  • One project per directory.
  • Keep data, code, and outputs in separate subdirectories.
  • Data is read-only; outputs should only be written by the code.

Version control & backup with git & GitHub

  • Create a git repository for each project and upload it to GitHub.
  • Commit meaningful code changes and sync with GitHub frequently.

Review, test, and validate

From the NIH Responsible AI policy:

Do not rely on the technology to be a software developer by proxy:

  • All well-written code must adhere to security design and ethical principles.
  • All code output needs to be reviewed for completeness, quality, efficiency, and, most of all, security.
  • Leverage manual and automated validation tools and testing technologies to help ensure these factors.
  • If you cannot identify or understand what a piece of AI generated code does, you should not use it.

AI outputs may be incomplete, inaccurate, biased, or fabricated.

Review

  • Read the entire output of each prompt and ensure you understand it.
  • Be skeptical. Do not blindly trust that the output is complete or correct.
  • Treat agents as untrustworthy, in terms of both inputs and outputs.

Review

If you cannot identify or understand what a piece of AI generated code does, you should not use it.

Content retrieved September 2026 from the NIH Responsible AI site. Please refer to the official site for the latest guidance.

Challenge yourself!

If you do not understand a piece of AI-generated code, dig into the documentation and tutorials to learn how it works.

  • Come across a large chunk of code with many patterns you don’t understand?
    • Prompt the agent to explain it line-by-line. Verify the explanation by asking for sources and reading them.
  • Use forums for in-depth help from people.
    • StackOverflow, biostars, Posit forum, GitHub discussions, your colleagues.

Testing & validation

Write tests to make sure the code behaves as expected.

  • Unit tests for individual functions on trivial inputs/data.
  • Integration tests run multiple functions or even an entire analysis on small & simulated datasets.
  • R: testthat. Python: pytest, unittest
file system tree
my-python-project
├── data/
├── src/mypackage
│   └── main.py
└── tests
    └── test_main.py
src/mypackage/main.py
def gc_content(seq):
    """Fraction of G/C bases in a DNA sequence."""
    seq = seq.upper()
    return (seq.count("G") + seq.count("C")) / len(seq)
tests/test_main.py
from mypackage.main import gc_content

def test_gc_content():
    assert gc_content("GGCC") == 1.0
    assert gc_content("ATAT") == 0.0
    assert gc_content("atgc") == 0.5

Testing & validation

Run tests before accepting code.

Use GitHub actions to automate.

Testing & validation

Use linters and code quality checks.

  • Ensure code is formatted for readability, quality, and syntax is correct.
  • Security and vulnerability scanning with GitHub Advanced Security.
  • R: air. Python: ruff.

Use pre-commit to run checks automatically on every change.

Document everything

Inline comments, function docstrings, vignettes, tutorials, getting started guide

Rscript
#' Add together two numbers
#'
#' @param x A number
#' @param y A number
#' @returns The sum of `x` and `y`
#' @examples
#' add(1, 1)
#' add(10, 1)
add <- function(x, y) {
  x + y
}

Document how you are using agents

from the very beginning of the project:

Create a document outlining how you will and will not use LLMs and agents.

docs/ai-usage.md
- Human responsibilities: Formulate the problem
  statement, design the software,
  validate the results, write the interpretation.
- Agent roles: assist in generating code,
  unit tests, and function documentation.

Disclose use of LLMs and agents in commit messages, issue comments, and pull requests.

Responsible agent use to minimize risks

 

Practice Risks minimized

Follow reproducible practices unreproducible work, destructive agent actions

Review, test, and validate all code incorrect methods, bugs, inefficiencies, malware

Document everything unreadable code, unusable code, lack of transparency

A checklist for agent-assisted Bioinformatics

Check off every item in this checklist before you trust LLM-generated code

1. Understand

2. Test

3. Sanity check

4. Make it reproducible

5. Own it

Final reminders

LLMs produce outputs that look like a plausible response to a prompt 🦜

  • View these models as another tool in your toolbox alongside IDEs, HPCs, and other software.
  • Interpreting the meaning of the generated outputs is your responsibility. Treat it as a learning experience!

Agentic tools can accelerate bioinformatics 🚀

  • Just make sure you’re facing the direction you want to go!

AI Use Statement

  • Human roles: all text content was written by the author and reviewed by colleagues.
  • Generative AI use: Copilot was used for reformatting and syntax lookup while drafting this presentation.
  • Images: image sources are noted on the slides where they appear; images created by others may or may not have used GenAI for assistance. Images listed without a source were created by the author, without GenAI.

Resources