AI-Assisted Coding for Researchers

An entry-level guide for using Claude Code or Codex with VS Code for everyday research coding.

This guide covers both tools. Use the toggle above to switch — steps marked with a tool tag change with your choice; everything else applies to both.

What is AI-Assisted Coding?

AI-assisted coding tools like Claude Code and Codex act as a knowledgeable collaborator you can talk to while you work — like having an expert sitting beside you who can read any file in your project and answer questions about it. You can ask it to explain an unfamiliar file, trace how data flows through a function, or help you understand why code is written the way it is. The AI reads the code alongside you — it does not run it or guarantee correctness, but it can save hours of digging through documentation.

A note on "vibe coding"

You may have heard the term vibe coding — letting an AI write code from a plain-language description and running it without really reading or understanding what it produced. It can be a fast way to throw together a prototype, but it is risky: the AI may generate code that looks right and runs without errors yet does the wrong thing. In research that is especially problematic, because a wrong number often looks just as plausible as a correct one. This guide focuses on a more careful way of using AI — to understand code and to support your own judgment, reviewing what it produces rather than accepting it blindly.

⚠ AI makes mistakes — your review is essential.
AI tools can give confident, fluent answers that are simply wrong: a misremembered function, an outdated API, a subtle logic error. Always check what the AI tells you against the actual code and documentation, and never run, trust, or publish AI-generated code without reading and testing it yourself. The AI is a collaborator, not an authority — you remain responsible for the result.

Claude Code and Codex can both run inside VS Code as extensions. Codex also has a terminal-based CLI, but this beginner guide uses the VS Code extension path so you do not need to install Node.js just to get started. The explanations and example prompts are the same either way.

Key Concepts

If these terms are already familiar, skip ahead to Setup.

The AI tools, companies, and models

A quick map of the names you'll come across — the companies, their AI assistants, the coding tools, and the models that power them.

A quick tour of the VS Code interface

When you open VS Code, the window is divided into a few main areas — it helps to recognize them before you start. The screenshot below shows them; the table that follows explains each one. For a fuller description, see the official VS Code User Interface guide.

Setup

Your First Session

In this session you'll use your AI assistant to do a small but real piece of data work — loading, cleaning, and visualizing a dataset with scientific Python libraries. This is the everyday way researchers use these tools: you describe what you want, the AI helps you write the code, and you check that it does the right thing. You don't have to write the code from scratch — but you do need to read and understand what the AI produces.

Set up a practice folder

1. Create a new, empty folder somewhere convenient (for example, penguins-practice) and open it in VS Code: File → Open Folder. This folder is your workspace.
2. Open a terminal inside VS Code with View → Terminal — this is where code runs and where software gets installed.

Open the assistant

Claude Code Press Ctrl+L (Windows/Linux) or Cmd+L (Mac) to open the Claude Code chat panel.

Codex Open Codex from the VS Code sidebar. If you do not see it, restart VS Code after installing the extension.

Your first task: set up the Python environment

This exercise runs on Python and a few scientific libraries. Rather than installing them by hand, let the assistant do it — setting up an environment is itself a normal, useful piece of AI-assisted work, and a good first thing to try. Give it this prompt:

Follow along as it works: it will run commands in the terminal, and may ask you to confirm a step or to close and reopen the terminal so a fresh install is picked up. Read what it is doing rather than just clicking through — this is exactly the "understand what the AI does" habit this guide is about.

Fallback: the Anaconda distribution
If the install runs into trouble — or you would rather get everything in one download — install Anaconda (or the lighter Miniconda). It bundles Python together with pandas, seaborn, and matplotlib, so the practice session works without a separate install step. Let your assistant know you are using Anaconda so it uses the matching conda commands.

The task: clean and visualize the Palmer Penguins dataset

The Palmer Penguins dataset records body measurements — bill length, flipper length, body mass, and more — for three penguin species. A few rows have missing values, which makes it a realistic example for practicing data cleaning. It loads in one line through the seaborn library.

Create a new file named penguins.py in your practice folder (or a Jupyter notebook, if you prefer) — you'll build it up as you go. Work through these prompts with your assistant one at a time. After each one, read the code it gives you, paste it into penguins.py, run it, and check the result before moving on. If a line is unclear, ask the assistant to explain it.

Going further

Once the basics work, ask for more: a histogram of body mass by species, a table of average measurements per species, or a different chart type. Each time, ask the AI why it chose a particular approach — that is how you learn to use the libraries yourself, rather than just collecting answers.

Sample solution

Try the prompts yourself first — working through them with the AI is the point of the exercise. If you get stuck, or just want to compare, you can reveal one possible solution below. Your assistant's code may look different and still be correct; whatever you end up with, make sure you can read and explain every line.

import seaborn as sns
import matplotlib.pyplot as plt

# 1. Load the dataset and take a first look
penguins = sns.load_dataset("penguins")
print(penguins.head())
print(penguins.columns.tolist())

# 2. Check for missing values
print(penguins.isna().sum())                     # missing values per column
print("Rows with any missing value:",
      penguins.isna().any(axis=1).sum())

# 3. Handle the missing values
#    dropna() removes rows that have gaps.
#    fillna() would instead fill them in (e.g. with a column average).
#    Dropping is simplest here; filling keeps more rows but invents values.
penguins_clean = penguins.dropna()

# 4 & 5. Scatter plot of bill dimensions, colored by species, with labels
sns.scatterplot(
    data=penguins_clean,
    x="bill_length_mm",
    y="bill_depth_mm",
    hue="species",
)
plt.xlabel("Bill length (mm)")
plt.ylabel("Bill depth (mm)")
plt.title("Penguin bill dimensions by species")
plt.legend(title="Species")
plt.show()

Tips for Asking Good Questions

The prompts in the left column are natural starting points — the versions on the right are more specific and tend to get better answers:

General rule: the more context you give, the better the answer. Tell the AI your background, what you're trying to understand, and why.

MCP in practice: NotebookLM

Google NotebookLM is a research tool where you upload documents, papers, and notes and ask questions about them. Using MCP (see Key Concepts), you can connect NotebookLM to your AI assistant — so Claude Code or Codex can draw on your NotebookLM notebooks while it helps you, for example pulling facts from a paper you saved there.

This part is optional and a little more advanced than the rest of the guide, but it is a good first taste of how MCP extends what your assistant can do.

What you'll need
Python (installed in the previous section), a Google account with NotebookLM access, and a web browser. The connection is made by a community tool, notebooklm-mcp-cli — look over what it does before granting it access to your Google account.

1. Install the NotebookLM MCP tool

In a terminal (View → Terminal), run:

pip install notebooklm-mcp-cli

This gives you two commands: nlm (a command-line tool) and notebooklm-mcp (the MCP server your assistant connects to).

2. Sign in to NotebookLM

Run nlm login. This opens your browser; sign in to your Google account, and the tool captures the sign-in automatically. Confirm it worked with nlm login --check.

3. Connect it to your assistant

Claude Code Run:

nlm setup add claude-code

Codex Run:

nlm setup add codex

Then check the connection with nlm doctor.

4. Restart and try it

Claude Code Restart Claude Code, or type /mcp in the chat to reconnect.

Codex Restart Codex so it picks up the new connection.

You can now ask your assistant things like:

Setup commands can change between versions — these follow notebooklm-mcp-cli v0.6.9. If something doesn't work, check that project's current README.

This guide was itself created with AI-assisted coding — drafted using Claude Code, then reviewed and edited by its authors.