LLMs are part of the R workflow now

An LLM (ChatGPT, Claude, Gemini, etc.) predicts likely text from a prompt. For an R user that’s useful for:

• Explaining errors: paste a cryptic message, get a plain-English cause.
• Drafting code: “write a ggplot of X by Y, faceted by Z.”
• Refactoring: “make this tidyverse instead of base R.”
• Learning: “what does across() do, with a small example?”
• As a data tool itself: classify, extract, or summarize text inside a pipeline.

Three places you’ll use one

Be specific

A vague prompt gets a vague (often wrong) answer. A good R prompt includes:

1. The goal: what the output should be.
2. The data shape: paste str(), glimpse(), or dput(head(x)).
3. Anything you tried and (if applicable) the exact error.
4. Constraints: “use the tidyverse,” “base R only,” “no new packages.”

A reproducible example beats a paragraph

The single most useful thing you can hand an LLM (or a human, or Stack Overflow) is a reprex, which is a tiny, self-contained, runnable snippet that reproduces the problem.

# install.packages("reprex")
library(reprex)

# copy this to your clipboard, then run reprex() 
# it runs the code and formats code + output together that's ready to paste:
reprex({
  library(dplyr)
  tibble(x = c(1, 2, NA)) |> summarise(m = mean(x)) # why is m NA?
})

Built-in datasets (mtcars, iris, penguins) make great reprexes. This helper can run them too.

Weak prompt vs. strong prompt

What ellmer is

ellmer is the tidyverse package that provides a unified interface for accessing various LLMs from R:

• chat_anthropic(): Claude
• chat_openai(): GPT
• chat_google_gemini(): Gemini

# install.packages("ellmer")
library(ellmer)

chat <- chat_anthropic(
  model = "claude-opus-4-8", # current default Claude model (RIP Fable 5)
  system_prompt = "You are a concise R tutor. Prefer the tidyverse."
)

chat$chat("In one sentence, what does dplyr::across() do?")

API keys: never in your code

Calling a provider needs an API key (a secret password tied to a paid account).

# DON'T: a key pasted in a script gets committed to GitHub forever.
chat_anthropic(api_key = "sk-ant-REAL-KEY")

# INSTEAD: store it once in an environment variable ellmer can read automatically.
usethis::edit_r_environ()    # opens ~/.Renviron; add: ANTHROPIC_API_KEY=sk-ant-...
# restart R, then:
chat <- chat_anthropic(model = "claude-opus-4-8")  # key picked up from the env

LLM as a data step

The real power for us isn’t chatting, but rather running the same prompt over every row of a data frame. This approach can help turn messy text into structured columns since ellmer can return typed, structured output:

library(ellmer)
chat <- chat_anthropic(model = "claude-opus-4-8")

reviews <- tibble(text = c(
  "Loved it, arrived early and works great!",
  "Broke after two days. Very disappointed.",
  "It's fine. Does the job, nothing special."
))

# ask for a schema; ellmer enforces the shape
sentiment <- type_object(
  mood = type_string("one of: positive, negative, neutral"),
  reason = type_string("a 5-word justification")
)

reviews |>
  mutate(parsed = map(text, ~ chat$chat_structured(.x, type = sentiment))) |>
  unnest_wider(parsed)

This is purrr + a prompt: text in, tidy columns out. That’s the data-science use.

LLMs are confident, not always correct

An LLM generates plausible, not 100% true, text. You should expect:

• Hallucinated functions / packages like dplyr::summarise_with() that don’t exist.
• Subtly wrong code that runs without error, gives the wrong number.
• Outdated idioms, i.e., deprecated funs(), old gather()/spread().
• Made-up facts and citations stated with total confidence.

Verification

For any code an LLM gives you:

Use it wisely

• Learn from it, don’t just paste. Ask why, ask for a small example, then reproduce it yourself.
• Keep prompts small and specific.
• Prefer reprexes and built-in data.
• Track what you used.

In-class activity (~20 min)

Use whatever LLM you have access to (chat window is fine, no API key needed).

1. Explain an error. Run this, then ask the LLM to explain and fix it. Verify the fix runs:

   library(dplyr)
   penguins |> group_by(species) |> summarize(avg = mean(bill_length_mm))

   (Why NaN/NA? What’s the one-argument fix?)

2. Generate a function. Ask for an R function that takes a numeric vector and returns its mean, median, and SD as a named tibble. Then break it: feed it c(1, 2, NA) and a length-1 vector. Did the LLM handle those?

3. Catch a mistake. Find at least one thing the LLM got wrong, outdated, or could improve.

Wrap-up & looking ahead