Tutorial: AI in the Scientific Research Workflow (2026)

This tutorial is a written version of the conversations I keep having with students and early-career researchers about using AI tools in the scientific research workflow.

Students often ask me where to start learning AI, which is a great question! Most of the content I could point them to is either biased toward a specific AI company or not designed for research workflows. So I compiled this tutorial to help students and fellow researchers make informed decisions about using AI in their work.

1. How to think about working with AI

This tutorial positions AI as a research assistant working closely under your command. Used naively, AI introduces real risk: science demands a far higher bar for correctness than casual AI use. The rest of this tutorial helps you setup a reusable system that follows the core principles of a reliable AI research workflow:

1. Factuality: ground all AI output in real sources.
2. Traceability: make every claim trace back to a source you can open and verify. This in turn supports factuality.
3. Integrability: connect the AI to the tools you already use.
4. Reproducibility: push your work out of ephemeral chat interfaces and into files (data, scripts, and instruction files) that you can re-run, version-control, and share.

That said, none of this guarantees the AI strictly follows these principles. It is ultimately your responsibility, as the human user, to verify any AI output before you use it.

2. My recommended toolkit for 2026

I've packaged everything into a template repository on GitHub to make it easy for you to get started. Step 6 will show you how to set it up.

3. Set up an IDE

An IDE (Integrated Development Environment) is a program for writing and running code. I recommend working with AI inside an IDE, even if you never intend to write or read a line of code yourself. For research, an IDE gives you things an AI chat app can't:

• You stay in control of the system. Your data, scripts, and results are all visible in a file panel. Nothing is hidden inside a chat app.
• AI works in real files, not disposable messages. You can have AI write an executable analysis script, save a cleaned data file, or add a results table directly to your project. These are artifacts you can inspect and re-run (Principle 4: Reproducibility).
• You get the same AI models you already use. The IDE extensions connect to the exact same models you already use. You're not downgrading the AI, but just upgrading the environment around it.

So, which IDE should you use? I recommend Visual Studio Code ("VS Code"). It is free, it runs on Windows, Mac, and Linux, and every major AI model has an extension for it.

4. Choose your AI agent

You can think of the AI agent as the assistant who works in the IDE with you. Before picking one, let's understand what an agent actually is.

As a computer scientist I think of an agent as a machine learning model (specifically, a large language model, or LLM for short) wrapped in a loop. The agent loop is an algorithm that follows a standard pattern: read → decide → act → observe. Let's illustrate this idea in pseudocode — a human-readable description of an algorithm:

while not done():
    state = read()
    decision = decide(state)
    result = act(decision)
    observe(result)

And here's the same idea in plain language:

Today, agents typically let you switch between a few modes:

The agent harness versus the model

We can also describe an agent using a simple mental model: agent = harness + model.

read → decide → act → observe ↺

Understanding this distinction matters because effective use of AI requires choosing both. An excellent model can prove useless inside a poor harness, while a simpler, cheaper model paired with a good harness may perform surprisingly well. To help you think about the distinction when using these systems, ask yourself which part is the real bottleneck — the reasoning of the model, or the scaffolding around it?

Which agent harness should you choose?

Pick a harness that installs directly inside VS Code. Two popular options today are GitHub Copilot and Claude Code. Start by checking what your university or workplace may already provide. GitHub Copilot is a reasonable default and comes with a free tier, so that's what we'll use in this tutorial.

5. Choose your LLM model

Which model should I use to power my agent?

The best practice here is to choose the right model for the right task. Models come from several providers, but the more useful distinction is that each provider offers a tier of models. I personally use a two tier mental model to help me decide:

I recommend experimenting with different providers to see which ones you like working with, and settling on two for your everyday work: a fast default and one highly capable model.

The model is where the cost is incurred

Recall the mental model from Step 4: agent = harness + model. The harness is usually a fixed subscription, but the model is metered. Every request you send is priced by the number of tokens (roughly, pieces of words) it reads and generates, so the fancier models cost several times more per request than the cheaper ones. This is the main running cost of working with AI, and it is the one you control directly.

6. Setup your workspace like a scientist

A clear directory structure keeps your work reproducible and makes it obvious where everything lives (Principle 4: Reproducibility). It also gives the AI a clean map of your project, so the agent behaves more predictably and is easier to steer.

The good news is that I've already set this up as a template! You just need to pull it into your VS Code workspace.

In this step we'll get the template setup on your computer. In the steps that follow we'll walk through what it contains and how to use it.

7. Learn the core AI concepts

If there's one thing I want you to take away from this tutorial, it's the concepts in this section. At the time of writing (mid-2026), these are emerging as standard conventions for working with AI. Later in Step 8, you'll apply these concepts to a real research workflow.

Markdown: the plain-text format AI reads and writes

You'll notice many files in the template end in .md. These are Markdown files, a simple way of writing formatted text: # for a heading, **bold** for bold, - for a bullet point, and so on. Markdown is readable as plain text, and AI models read and write it fluently, which is why it's become sort of a default format for working with AI.

Some types of Markdown files are long-standing conventions from software development. The README.md file is the classic example: by universal convention, it is the front page of a project that tells anyone who opens it what the project is and how to use it. Other Markdown files we'll see in the template are newer conventions emerging in the AI community.

Instruction files: telling the AI how you work

Instead of re-explaining your project and your preferences at the start of every conversation, you can write instruction files that the agent reads automatically. The common convention is AGENTS.md, a Markdown file that most agents understand to hold your project's context and your working preferences.

For example, an AGENTS.md for a biology project might tell the agent which organism and assay you work with, which reference genome build to assume (e.g. GRCh38), your statistical conventions, that data/raw/ is read-only, and that you prefer R for statistics but Python for general scripting.

Tools and skills: connecting AI to the tools you already use

By default, an LLM answers from its training data alone. For a scientist, this is dangerous: a model can hallucinate a citation or misrepresent a technical concept. Tool calling addresses this. It connects the model to the systems you already use (literature search engines, databases, etc.), so the model retrieves real information.

We won't cover it in this tutorial, but one tool calling approach you may encounter is MCP (Model Context Protocol). When connected to an MCP server, the agent discovers and calls available tools automatically.

This tutorial uses the skills approach. A SKILL.md file describes a capability to the model, typically alongside scripts that implement it. Google DeepMind has created a collection of agent skills designed for scientific research tasks. These are already integrated into the template and ready to use.

Information management: memory for your agent

How agents handle memory is still an evolving area. The underlying LLM model is limited by its context window, the amount of text it can process at once. Within that limit, the model can only reason over what is currently visible to it.

An agent harness therefore needs a persistence layer outside the model itself. This layer selects, stores, and retrieves information during and across conversations and workflows. In practice, you build this layer from files and databases. For example, the agent might append progress updates to a markdown file, or maintain a database of experiment runs.

8. Putting it all together: a complete workflow

It's time to bring everything together on a real analysis. In this worked example we'll do a differential expression analysis of RNA-Seq data, driving each step through your AI agent.

RNA-Seq measures the abundance of RNA transcripts for each gene in a sample, giving a snapshot of which genes are "turned on" and how strongly. Differential expression analysis compares those gene activity levels between two conditions (e.g., drug-treated and untreated samples) to find which genes are significantly more or less active in one group than the other.

The full walkthrough lives in the template at docs/worked-example.md. It's a document you read and follow, not a skill — the agent isn't invoking a capability here, you're steering it through an analysis step by step.

Setup

Switch to Agent mode for this worked example, so the agent can read files and run commands for you. The first thing we'll do is run a skill that sets up the project: it installs the software dependencies the analysis needs (Python, the analysis libraries, and the tooling for the science skills).

Data

The data comes from Himes et al., "RNA-Seq Transcriptome Profiling Identifies CRISPLD2 as a Glucocorticoid Responsive Gene that Modulates Cytokine Function in Airway Smooth Muscle Cells." PLoS ONE. 2014 Jun 13;9(6):e99625. PMID: 24926665. It is popular in several bioinformatics tutorials, including this F1000Research workflow and this RNA-seq workshop.

The original study explored the molecular mechanisms through which dexamethasone, a glucocorticoid used in the treatment of asthma, suppresses inflammation in airway smooth muscle (ASM) cells. The study used a next-generation sequencing technique called RNA-seq to sequence eight samples: four human ASM cell lines, each measured treated with dexamethasone and untreated.

We will use this data to investigate the question: "How does dexamethasone treatment change gene expression in human airway smooth muscle cells compared to untreated cells?"

Using skills: literature search

Let's start by taking a look at the existing literature. A skill turns this into a fixed procedure: the agent queries a real database through a defined script.

Making a plan and running the analysis

This step involves creating Python scripts that execute code for statistical analysis. Here we will learn best practices of the plan-and-act approach: planning mode lets you see how the agent intends to approach the work before it generates any code files.

This is where we want to get to by the end of this step — using AI to help us generate the Python scripts that produce figures like these examining our data:

Presenting the results

We have analysis results, and now we want to present them. First we'll use two more science skills, ensembl_database and uniprot_database, to annotate the top genes found. Then we'll use Mermaid diagrams to see how AI can generate a flowchart of our workflow, making it easier to communicate our process to supervisors and collaborators. Finally, we'll see a trick for using AI to generate slides with LaTeX — I ship my own skill for this that you can take and repurpose for your own work.

Part 1: Annotate the top genes

Let's invoke more of the science skills to ground our analysis in facts for the presentation. We'll turn the anonymous Ensembl IDs in top_genes.csv into readable gene and protein information, fetched from Ensembl and UniProt.

Part 2: Visualise the workflow with a Mermaid diagram

This part shows how you can use AI to search your project workspace and summarise your work in a Mermaid diagram. This is useful when you need to clearly explain your methods to a supervisor or collaborator. Mermaid is a great diagramming tool for AI because it is text-based code that VS Code can render into visual charts.

Part 3: Turn your work into slides

Here's a trick I don't think many people know about (if you've tried to use AI to make PowerPoint slides, you'll know the frustration): you can use LaTeX to make slides. LaTeX is a plain-text typesetting system: you write structured markup (not unlike Markdown, but more expressive) and a compiler turns it into a formatted PDF. Because it's just text, the agent can write it, edit it, and recompile it like any other code, instead of fighting a slide-editor UI.

Ask AI "help me make slides for my project" and it will use a skill I created called make-latex-slides. It will interview you and help construct the slides.

9. Where to go from here

You now have a template for AI-assisted research workflows. The next step is to make it your own: either run the make-your-own skill and work with your agent to adapt the template to your project, or take the parts you find most useful and setup your own template. Once you start using it on real work, it's worth watching for a subtle risk: letting AI do so much that you stop building your own understanding of the project underneath it.

There's a term going around for this: cognitive debt — explored in the context of software engineering by computer scientist Margaret-Anne Storey (read her post), and in the context of AI-assisted writing by an MIT Media Lab study, Your Brain on ChatGPT. The same risk applies to research. An agent can produce a literature summary, a script, and a results table faster than you can read any one of them, and your own grasp of the project quietly erodes.

My advice: be selective about what you hand off to AI, and limit how much you accept at once. Passively offloading your work to AI and accepting its output as is drives cognitive debt. Steer it instead: review intermediate results and redirect as you go, and only fully delegate the kind of repetitive tasks that you already understand.