A no bullshit guide to LLMs

A talk from useR! 2025

A no bullshit guide to LLMs

I’m busy preparing for posit::conf() so no new content this week, but I thought you might enjoy this write up of a talk I gave about a year ago at useR! 2025. I find it interesting to reflect on just how much has changed in the last 12 months. Not least, the agentic coding revolution where now LLMs are writing the majority of code for most software engineers (including me!). And Claude is no longer my favourite model given how it’s become even more relatively expensive, and the quality of its writing has dropped substantially. My new favourite is Kimi K3, which feels somewhere between Opus and Fable in terms of quality, and is closer to the cost of Sonnet.

Introduction

What I want to give you is a no bullshit guide to LLMs. I think there’s a lot of bullshit about LLMs in the air, so my goal is to hopefully clear a little bit of that.

I think probably many of you have big feelings about AI. I certainly do. If you read about AI, on the one hand there’s so much unbridled optimism, and on the other, so much skepticism. And as you start to engage with it yourself, I think you experience both of those emotions, because LLMs can seem both incredibly, surprisingly, intelligent and also incredibly, surprisingly, stupid. So I’ll show you a few examples of that. But if you don’t feel conflicted about AI, that’s weird.

Oil painting of a shadowy figure amid swirling clouds and circuitry

My feelings of existential dread swing between mild and moderate. They’re currently mild at the moment, but it does feel like my identities as a software engineer and a data scientist are under threat. And it’s very easy to feel disempowered right now. One of the things I do that’s not so helpful is I get drunk and donate money to good causes. I’m not going to promote that as a strategy.

Oil painting of a person picking up trash

But the other thing that I’ve found really useful is just to try and do one small thing to make the world a better place. So occasionally, when I’m feeling particularly down, I’ll just go out and pick up some trash around my neighborhood. And that reminds me that it’s not my job to fix the world. All I can do is make my little bit of the world a little bit better.

And so I want to give you a bit of that today. I want to give you some ways that you can engage with AI and LLMs that hopefully empower you and make you feel a little bit more in control of your future. So my two goals today are to give you a handful of useful skills and to demystify a few of the many, many, many jargony terms that come with AI.

Two main goals of this talk: useful skills, demystify jargon

And I’m going to do this mostly in R, using the ellmer package. ellmer is a package that me and a few others at Posit have been working on recently. As you might guess from the name, it’s about using LLMs in R, and it has the honor of being the first package name that I’ve created by adding vowels rather than taking them away.

So here’s some ellmer code. We’re gonna start by loading ellmer, obviously, and then I’m gonna create this chat object. Here I’m using chat_anthropic(). I’ll show you a few other models today, but this is my starting place. This is my favorite model. And then I can interact with it from R in exactly the same way you can interact with it on the web.

ellmer code: creating a chat with chat_anthropic() and asking “Who are you?”

LLMs kind of suck

I think one of the things that makes LLMs so hard to think about is they kind of turn upside down what we think of as computers being good at and what we think of computers being bad at.

Psychedelic painting of a computer

Because you think of computers as being good at multiplying numbers together, but it turns out that LLMs are pretty bad at multiplying numbers together. They’ll certainly do their darndest and get something that looks kind of right, but they’ll be a little bit off.

LLMs can’t multiply big numbers

In fact, they can’t even count. So I asked this version of Claude how many n’s are in the word unconventional. I won’t make you think too much: it’s actually four n’s. But Claude confidently said two n’s.

LLMs can’t even count: Claude says there are 2 n’s in unconventional

And then I asked it again, and it said there were three n’s.

And they’re not even consistent: now it says 3 n’s

And then, the cool thing about this being an API: I asked one hundred times. 14 times it said there was one n, 76 times it said there were two n’s, and 10 times it said there were three n’s. So zero times it got it correct. And this is an easy problem!

And another run says 1 n, with a tally of 100 runs: never correct

Now you might notice I’ve specified this model here, and that’s because Claude fixed this problem. So now if you ask Claude how many n’s are there in unconventional, it gives you the right number. And this is not because the model has become more intelligent. This is because Anthropic is embarrassed by the fact that its LLM can’t count the number of letters, and has adjusted their prompt to make it do this correctly.

And the goal posts are constantly moving: Claude Sonnet 4 now counts 4 n’s correctly

And interestingly, if you’ve been following any of the news about ChatGPT’s latest model, it has exactly the same problem. Like how many b’s in blueberry? This is a simpler problem, I think. It thinks there are three b’s rather than two.

ChatGPT 5 miscounts the b’s in blueberry

So LLMs kind of suck, right? The results are stochastic, their models are constantly changing. The difference between good results and bad results can be razor thin (hence the term “the jagged edge”). And they always give results that look plausible, and it’s pretty unusual for them to say “oh, I don’t know” or “this is just my best guess”. They don’t admit doubt or lack of knowledge.

So LLMs kind of suck: stochastic results, changing models, jagged edge, plausible answers, no doubt

Yes, and

So I think all of those things are true, and yet LLMs can do things that computers traditionally could not. We can ask them to write poems, like give me a limerick about the tidyverse.

Computers can now write poems: the tidyverse limerick. “A coder who worked with great zeal, said tidyverse makes data feel real. With dplyr to wrangle and ggplot2’s angle, my pipe dreams are now a good deal.”

Maybe not the best limerick in the world, but certainly a better limerick than I can come up with in five seconds.

You can also use AI to roast your colleagues. I gave a talk at the JSM a couple of days ago and came up with a few roasts. I particularly like the one for Roger Peng: “Roger believes in reproducibility, which is great because his jokes in lecture reproducibly bomb every time.”

And roast your colleagues: roasts of Jeff Leek, Jenny Bryan, Mine, and Roger Peng

Or as Matt pointed out, you can of course combine the two and roast yourself with a limerick.

Or roast yourself poetically: a limerick roasting Hadley

And you can use LLMs to create art.

And create art: the ellmer hex logo and AI-generated paintings

And you can use them to make fun games. So I’m gonna give you a live demo.

And make fun games: a quiz master system prompt with live_browser()

So I’ve asked it to create a fun quiz game that asks challenging questions about the tidyverse. So welcome to Tidy or Die!

The quiz game introduces itself: Commander dplyr and the gauntlet of tidyverse challenges

Okay, so let’s see. You have a dataset called sales and you want to keep only rows where the revenue column is greater than a thousand. Which tidyverse function? Okay, let’s do a vote. Who thinks A? Okay, who thinks B? Okay, who thinks C? And who thinks D? Okay, let’s say B.

Round 1: which tidyverse function keeps only rows where revenue is greater than 1000?

Okay, so let’s do another question. Okay: I want to fit a linear model predicting values from row number, extract the R-squared value, and then return a tibble with group and — wow, okay. Which approach is most tidyverse elegant?

A much harder question: fit a linear model within each group and extract the R-squared

So it’s fun, right? You can certainly use LLMs to stop learning about anything, but you can also use them to learn about things in new ways.

And there’s lots of practical things you can do too. Here I’m going to take advantage of the first argument to chat_anthropic(), which provides a system prompt. A system prompt is not something you can use when you’re using a chat app on the web. But it’s something that’s going to set the tone for all of the following conversations, and I just say “be terse” here just so the answer will fit on one slide.

Or more practically: a “Be terse” system prompt, and asking for the name of a half-remembered base R function (apropos())

I think one of the things that is challenging about Google, or search in general, is if you know the name of the thing you’re looking for, you can find out a ton of information. If you don’t know what you’re looking for, you can’t. And LLMs often give us that ability to say: I’m looking for this thing that I vaguely remember, it does something like this — and now you can get an answer. And I think that’s tremendously empowering.

One thing I used it for recently: as I was working on httr2 and needed to add a new feature, I was like, someone must have thought about this problem before, so I asked Claude. And it told me about the leaky bucket algorithm. And that algorithm and that metaphor were so powerful and so useful for the problem I was tackling and would have been very, very difficult for me to discover by googling.

Asking what algorithms to consider for req_throttle(): token bucket, leaky bucket, sliding window, exponential backoff

Or as JD Long puts it succinctly:

JD Long: “Counting letters in words is the dumbest heuristic to test an AI model. It’s not useful. And it’s misleading.”

I think another thing that’s challenging about LLMs is that they can be bad at simple things and good at complex things. You can’t just give up on them because they make these really silly mistakes on very simple problems. That’s not really what they’re designed for. They’re designed to do things that computers are not traditionally good at.

So again, my goal with this talk is to give you some useful skills and to demystify some jargon.

The two goals again: useful skills, demystify jargon

So let’s dive in to talk about three particularly important topics. The first is using LLMs to extract structured data, to turn all sorts of data into nice rectangles. Then I’ll talk a little bit about tool calling, which is a way to add extra capabilities to LLMs and to create interactive agents. And then we’ll finally talk a little bit about how you can use LLMs to help you with your programming.

The three topics: 1. Structured data, 2. Tool calling, 3. Coding

Structured data

So, to tee this up, I want you to take a couple of seconds, just look at this data here, a very simple vector, and I want you to think: how would you go about extracting the name and age of each person?

Your turn: how would you extract name and age from these sentences?

So if you’ve ever collected data from humans, you’ve encountered situations like this. There’s like eight people from Posit here. And Mine was saying that everyone put a different name for our company in their conference registration!

If you look at this data, maybe you could come up with some regular expressions. Like the age: you could use digits, but oh, some people spelled it out, and we’ve got “the big 5-0”. Names are even harder: they’re mostly one word, but not always. They often start with a capital letter, but there’s lots of other capital letters in there. So trying to do this deterministically with code is going to be really, really hard.

But this is something that LLMs are pretty good at. They’re not going to hallucinate, because all the data’s there. It’s just finding the right thing.

LLMs are generally good at this sort of task: extracting name and age with plain chat

But wouldn’t it be nice if, rather than getting a string which we’ll need to parse in some way, we could get an R data structure back? Maybe something like this.

But wouldn’t it be nice to get an R data structure?

Well, you can. And all you really need to do here is give the LLM a description of the schema — exactly what you want to get back from it. Here I’m saying I want an object. This is a JSON schema; JSON is kind of the lingua franca of the web, and so this is what LLMs are pretty good at speaking as well. I want an object, which is like a named list. The name is a string and the age is a number. And now I can use this with chat_structured() instead of chat(), and I get a nice list back.

Well you can: defining a schema with type_object() and using chat_structured()

And I can do this to many prompts all at once, in parallel, using another ellmer function called parallel_chat_structured().

And you can do this to many prompts at once with parallel_chat_structured()

I think this is a data science superpower, because you can now go from all sorts of unstructured data — not just text but, as I’ll show shortly, images and video and audio — into nice rectangles. And if there’s one thing that data scientists are good at, it’s working with rectangles.

Oil painting of a flying data science superhero

So here’s another little example. Here I’ve got four images:

And you’re not limited to just text: four animal photos

I’ll just give you a little bit of code. I’m going to find all of the files in the animals directory. I’m going to use this content_image_file() function — that’s how you tell ellmer you want to send an image to the LLM. I’m going to say what I want back: I want the animal and the background color. And then I’m going to call that same function again.

And it’s not a lot of code: content_image_file() plus a schema

And again, there’s a little bit of stochasticity there. If I call this four times, I get four slightly different answers.

Four runs give four slightly different tables

But when you look at how they vary, this is kind of fair. What animal would you say this is? I think kitten and cat are both valid answers. What’s the background? Well, it’s kind of a beige gray.

The variation is fair: kitten vs cat, beige vs gray

So again, you’re not going to get 100% reliable answers, but I think the problem here is that we haven’t been clear enough with what we want.

The other thing that’s interesting here is that once you’ve got that rectangular data frame, now you can use all of your statistical tools with it. And statistical tools don’t assume that the data is measured without error. The assumption that there’s going to be mistakes and variation and differences is fundamentally baked into statistics. And I think this combination of structured data extraction and statistical modeling is super, super powerful.

But of course you’re gonna really want to think about that. You’re gonna think about: is this the right prompt? Am I getting the right examples? If you want to do that in the LLM world, that’s called evals — evaluating your LLM. And Simon Couch, my colleague, has been working on the vitals package, if you want to make that a little bit easier. Simon’s on the tidymodels team, and so the goal is to really bring what we know about evaluating statistical models, combine that with the state of the art of evaluating LLMs, and give you something that’s well principled and well thought out.

The vitals package hex logo

Tool calling

The next thing I want to talk about is tool calling. And I want to illustrate that with a problem — another thing that LLMs are bad at. If you ask an LLM what day it is today, best case scenario it’s going to say: I don’t know. If you ask this of ChatGPT, it actually just makes up a date, which is not very reassuring.

LLMs don’t have access to live data about the world

And LLMs can’t do anything, right? They’re stuck in a box. You can’t say: hey LLM, delete the CSV files in my directory.

Or the ability to make changes to the world

We can get around both of these limitations by using these things called tools.

Oil painting of a toolbox

And a tool is actually something really simple. It’s just a function along with some metadata. I’m obviously going to write R functions; but you can write them in any language. And then you’re going to provide a little bit of metadata to tell the LLM when it might want to use that tool.

tool = function + metadata

So for example, I can create a tool. This tool I’ve called today. It’s going to call Sys.Date(), which gives you today’s date. Now I’m going to say what it does, and I’m going to say what arguments it takes, which in this case is none.

A tool is just a function with some extra metadata: the today tool

And now that I’ve empowered my chat, I can ask it what day is it today, and it can tell me.

Now the model can know what day it is

And when you look at this, you might be a little surprised. Is Anthropic running R on their servers? I mean, that would be cool, but certainly a little surprising. That’s not actually how tool calls work. When you send a request to the LLM, the LLM is going to be like: oh, okay, I recognize that I need to call this tool, and it’s going to send that information back to you. That’s going to get intercepted by ellmer, and ellmer is going to call the tool and return the result back. Now the LLM has all the information it needs to answer your original query. So the neat thing about this is, because the code is running on your computer, you can do anything that you can do on your computer.

Diagram of how tool calls flow between you, ellmer, and the LLM

One thing you could do, for example, is to give the LLM traditional computing powers. I could give it the power to multiply two numbers together.

We can use this to give the LLM traditional computing powers: a multiply tool

And now if I ask it to multiply two large numbers together, it can do that correctly, because it’s going to use that tool.

So now we get the correct result

And indeed, if you ask many of these LLMs on their websites to do these things, they’ll just write a little bit of JavaScript code, because this is just another tool that they can use to answer the question. The models — specifically the ones presented on their websites — have been trained not to try and do this stuff themselves, but to write a little program to do it.

ChatGPT writes JavaScript to multiply numbers

Agents

Oil painting of a figure walking through a golden landscape

That brings me to one of the most powerful things you can do with tools, and that’s to create an agent. If you’ve read anything about AI on the internet lately, you’ve probably heard the term agent or agentic a million times. And you probably still have no sense of exactly what an agent is. But it turns out, if you know what a tool is — and that’s just a function plus some metadata — it’s really easy to explain what an agent is. Because an agent is just a chatbot that’s been empowered with two tools: one that can read the state of the world, and one that can write the state of the world.

agent = reading tool + writing tool

So let’s make an agent. I’m going to give my chatbot the ability to list all of the files in the current directory.

An agent needs a tool to read state: ls

And I’m going to give it the ability to delete files.

And a tool to write state: rm

And now I can say: hey, delete all the CSV files in the current directory. It’s going to say: well, okay, to do that, I’m going to need to find out what files are in the current directory. So it requests that ellmer calls ls(). It’s gonna say: okay, I found two CSV files, a.csv and b.csv. I’m gonna delete those. It’s gonna send that tool call request back to ellmer. ellmer is gonna delete the files, and now it’s deleted those files on my computer.

Now my chatbot can delete files on my computer: the full tool-calling transcript

Hopefully when you look at this, you’re like: Hadley, what on earth are you thinking? You have just empowered an LLM, which is notoriously unreliable, to delete files on your computer.

Oil painting of a horrified woman staring at a red laptop

And certainly you can put a few guardrails around it, and there are some built into the LLMs — if you ask it to delete all the files on your computer, the model itself is gonna be like, that’s a bad idea, I’m not gonna do that. But basically this is the state of security today with agents. It’s the YOLO model.

Agents are interesting because they offer so much potential: you can now empower an LLM to do anything. But also so much danger: you’ve now empowered an LLM to do anything. And it’s going to take us, I think, collectively quite some time to figure out how to do this safely.

Coding

So that brings me to my third topic, which is using LLMs to code. I’ll first orient you to the main techniques for using LLMs to code. Hopefully you’ve seen many of these before.

Main techniques: web chat, inline autocomplete, in-IDE chat, agentic coding

The first one is the most basic. You just go into chatgpt.com and say: hey, give me a function that does blah, or, I need to write some R code that solves this problem. That’s kind of fine, but you’re constantly copying and pasting back and forth. This is like the old days, pre-R Markdown, where you’re copying and pasting results from Excel into your Word document; when something changes, you copy things back and forth again, and it’s very, very easy to get out of sync.

Now most IDEs are starting to bring in AI tooling. The first way is inline autocomplete: that’s when you start typing and the LLM — helpfully sometimes, and not so helpfully most of the time — suggests finishing your thought. I think one of the skills of programming today is being able to ignore that when it’s bad and accept it when it’s good.

You can also have chat that’s inside your IDE. This is just sort of a convenience. It’s exactly the same thing as chatting with ChatGPT, but you don’t have to copy things back and forth — you can just click a button, and the chat knows more about what you’re doing because it can see what you’re working on.

And then finally, the newest trend is agentic coding. This is things like Cursor or Claude Code, where the LLM is just going to go off and do a bunch of work. It’s going to write some code. It might write some tests, run those tests, and iterate for a little while.

Clear win: translations

There are lots of ways in which LLMs do pretty useless and horrible things when coding, but I want to talk about the things that I think are clear wins, and there are two.

The first clear win is translations. Whenever all of the information the LLM needs is there and it just needs to be expressed in a different form, they tend to do pretty well. So if you can really accurately write in pseudocode what you’re trying to do, LLMs are going to turn that into code in any language pretty reliably.

Clear win: translations — pseudocode to code, curl to httr2, LaTeX to Quarto, SQL to dplyr, SAS to R, words to regular expressions, image to Shiny app

One thing I use it for: often websites give you a curl command that you run on the console. You can ask an LLM to translate that to httr2 code. Or you can convert your LaTeX docs to Quarto, you can convert your SQL to dplyr, you can convert your SAS to R code, you can convert your words to regular expressions. Many of these things it’s going to get correct a lot of the time. And even when it doesn’t, just having that first shot at a translation can be really, really useful.

And I want to finish with one kind of cool example that my colleague George came up with.

George’s hand-drawn sketch of a penguins data Shiny app

I’m going to take a screenshot of this Shiny app that George drew, and I’m gonna pop open Positron chat, and I’m gonna drag the screenshot in, and I’m gonna be like: please make this into a Shiny app. And actually I need to stop running this Shiny app I was running earlier, so let’s do that first. Okay, please make this into a Shiny app.

Positron Assistant with the sketch screenshot attached: “Please make this into a shiny app”

And it’s certainly writing Shiny code much faster than I can write Shiny code. Is it any good? Well, we’ll find out in a couple of seconds. So now I’m just gonna click run. I’m gonna see this Shiny app. It’s not done a very good job, actually.

The first attempt at the penguins Shiny app

So this is one of these stochasticity things — it’s certainly done better in the past. But you can see it’s got the basic idea of the Shiny app, right? It’s got the variable, it’s got the distribution. The distribution’s not very useful because it only offers one thing. So we could say — let’s go back to my chat and be like: could you add box plots plus frequency polygon plus density plot. I have to say, one thing I particularly like about LLMs is that I don’t have to worry about correcting my spelling mistakes so I don’t look like an idiot. Let’s see how it does.

The rewritten penguins app, now with a distribution dropdown

Clear win: lowering activation energy

And that brings me to the other area where I think LLMs give you a clear win, which, and maybe this is not the best name, I think of this as lowering the activation energy. You can just do something very, very quickly. It might not be super correct or perfect, but it gives you something. Maybe that’s a quick demo or prototype that you can look at and be like: oh okay, this is cool, that’s not cool — it gives you some immediate feedback. Or maybe it’s something that’s just so awful, you feel compelled to fix it.

Clear win: lowering activation energy — demos, bad first drafts, scary bugs, unfamiliar domains, postponed unit tests

This is something that I find useful for writing. I’ll ask it to write about something, not because I think it’s gonna do a good job, but because I know it’s gonna do a bad job, and then I feel compelled to correct it. This reminds me of one of my strategies back in the old days of the R-help mailing list. Sometimes you ask a question and it’s just crickets — no one cares to answer. So instead of asking a question, you just state something confidently, and if you’re wrong, someone will dive in and correct you.

The other thing I’ve been using it for lately: I’ve been working on testthat. There are issues there that have been lingering for four or sometimes more years, because I’m like: oh, this is gonna be a lot of work. And so I’ve just been throwing Claude Code at it. I’m just like: take a stab. And sometimes it comes up with an answer, and I’m like: oh, that problem actually wasn’t that hard after all. The challenge has been all in my head this whole time.

It’s also great if you’re working in an unfamiliar area, whether that’s a new programming language or a new package or a new domain. LLMs get you good enough to be dangerous, for better or worse, very, very quickly. And I think Claude actually came up with a pretty good summary of this: “LLMs can make the cost of trying so low that you attempt things you’d normally postpone, avoid, or never get around to.”

Claude Opus 4.1: “The key theme: LLMs make the cost of trying so low that you attempt things you’d normally postpone, avoid, or never get around to.”

And I think this is a pretty compelling use case. You’re not going to want to trust everything it produces, but you’ve gotten unstuck, you’re moving forward. Sure, it’s going to make mistakes, but you’re going to learn from those.

Conclusion

To sum up: I feel like you can’t give a talk about LLMs without talking about some of the many, many, many concerns.

LLM concerns: cost/equality of access, environmental concerns, data privacy, evil billionaires

I think the first concern is the cost of, and the equality of, access. I will say, I’d really encourage you to sign up for an API key, put five dollars on it, and just see how far that takes you, because it takes you a surprisingly long way. The LLMs are getting cheaper and cheaper and cheaper, and you can do quite a lot of cool stuff for only five dollars. Also Google’s Gemini model is kind of in a distant third place, and so Google is just spending cash like anything to try and make it popular. And that means it’s got a very generous free tier right now, so you should take advantage of it. By and large, I think local models are not worth it. They can be worth it in general, but if you’re just getting started with LLMs, start with something that’s much more likely to give you positive results, which is Anthropic, OpenAI, or Gemini.

Another concern is the environment. I genuinely believe you should care about the environment, you should worry about climate change, you should think about how much water and electricity you’re using. But if you have flown on a plane in the last 12 months, that just blows away, by orders of magnitude, any environmental impact of your ChatGPT usage. So while I think it makes sense to think about this on a societal level, the actual impact of an individual ChatGPT query is very, very small, and you should be thinking about other ways to save water and power.

There are also lots of concerns about data privacy around LLMs. I think this is, sort of surprisingly, something that affects you more as an individual. Basically every large company’s data already lives on Azure or GCP or AWS. All of the data is already in the cloud, and all the LLM models are running in the same cloud. Most large enterprises do not have these concerns, because these big companies already technically have access to all of their data, but there’s lots of protection in place to make sure it’s not misused. So it is something you should think about as an individual: certainly if you’re working with any confidential data, you need to be very, very cautious about sending it to these models. But most businesses can negotiate contracts with these providers that ensure that your data is not going to be used to train future models.

Finally, the biggest concern I have, which I don’t have a good answer for, is evil billionaires. I feel like I’m becoming increasingly radicalized that billionaires shouldn’t exist.

So again, to come back to my first point: if you are feeling disempowered or out of control, or you don’t understand how AI and LLMs are gonna affect your future life, I’d really encourage you to just do one little thing. Do one little experiment that helps you understand what’s going on. I think you’ll find that empowering. I think you’ll learn that while there’s lots of hype around models replacing data scientists and software engineers, we’re a very, very long way from that happening in practice. They are very good at some things. They can be very useful and empowering tools, but they’re a long way from replacing our jobs.

Oil painting of a person picking up trash, again

The other thing I will say — the best defense is a strong offense. If you’re worried about your job being replaced by AI: it feels like managers are way more vulnerable to being replaced by AI, because so much of what a manager does is just summarize the information that they receive from multiple channels and report it out. So feel free to go on the attack against people higher up in your company.

The three topics, one more time: structured data, tool calling, coding

So in summary, I showed you three areas where I think LLMs are particularly interesting and empowering today. Use structured data extraction to turn unstructured data — text, images, audio, video — into rectangles; then you can apply all of your rectangle skills that you already have. Tools are a really neat way to extend the capabilities of LLMs. Tools are just functions plus metadata; you already know how to write functions, so you can now extend LLMs to do whatever you want, including creating agents that do really dangerous and stupid things. And then finally, LLMs are sometimes super amazing at coding, sometimes super terrible at coding, but I think the two areas where they give the clearest wins today are translations — whenever you’ve expressed an idea clearly in one language or one image, you can translate that to another — and lowering the activation energy, giving you the ability to experiment, to try things out, and to expand into new areas where you don’t know so much.