# Getting Started: Claude Code for Economists with Paul Goldsmith-Pinkham | Markus Academy | Ep. 162-1

https://www.youtube.com/watch?v=HzgByl5ZsWE

[00:08] Thanks for joining us
[00:10] for mini series on Claude code for
[00:13] applied economists
[00:15] with Paul Goldsmith Bingham. Hi Paul,
[00:17] good to have you.
[00:18] Hi Marcus, thanks so much for having me.
[00:21] Great. So today we learn how to use LLMs
[00:26] for empirical research, but this is part
[00:29] of a mini series and we had an earlier
[00:31] mini series with Ben Gallop who focused
[00:33] on economics and the theoretical
[00:35] economics. He showed us how to use LLMs
[00:37] with cursor. This was in December 2025.
[00:41] But he also had a video on prompting
[00:43] insights and on his new software
[00:46] refine.ink where you can actually run
[00:48] your paper through this software and get
[00:51] a referee report and get some feedback
[00:54] how to improve your paper. But today we
[00:56] will work with Paul on Claude code and
[01:00] to some extent co-work how to use this
[01:04] LLMs for applied economic research. So
[01:07] thanks a lot Paul. We're looking forward
[01:09] to your presentation.
[01:10] >> Great.
[01:11] Great, thank you so much Marcus. This is
[01:13] a real pleasure and I'm looking forward
[01:15] to this and I hope
[01:16] you know, it's so funny as I get ready
[01:18] to sort of share this is that you know,
[01:20] you say that you had you had Ben do this
[01:25] just in just in December
[01:28] and things have changed a lot even even
[01:30] since December. It's sort of remarkable
[01:31] how much of this is changing all the
[01:33] time. So I know I'm hopefully this will
[01:34] be useful to people cuz I know people
[01:36] are excited. So today we're going to be
[01:39] getting started really. I'm going to
[01:40] kind of overview and then I'm going to
[01:43] talk about the various things we'll talk
[01:44] about in the mini series. For this video
[01:47] I want to start by just kind of giving a
[01:49] brief motivation. I think
[01:51] Marcus you sort of reach a lot of
[01:52] people. Some people are going to be more
[01:53] excited about this than others. I wanted
[01:55] to give kind of two brief motivations
[01:57] about what you can think about. I think
[01:59] for one is that I found that these
[02:01] tools, especially for coding and for
[02:03] empirical research,
[02:04] really kind of let you do more faster.
[02:07] The distance, kind of how quickly you
[02:09] can go from oh, I have a brief idea to
[02:10] something that looks like an empirical
[02:12] result is
[02:13] is just
[02:14] so so much quicker than it is before. I
[02:17] think cleaning data, doing things I'm
[02:20] not totally sold or convinced on this
[02:21] idea that the raw AI ideas that you're
[02:24] getting without any kind of key insight
[02:26] yourself is that compelling yet. I think
[02:30] people sometimes refer to this as taste,
[02:32] but really the execution and the speed
[02:34] is kind of remarkable. It's really
[02:35] amazing. It really helps if you're an
[02:37] empirical researcher. I mean, just clean
[02:38] as we kind of all know, like cleaning,
[02:41] debugging, all of that is really
[02:43] painful. Um, it's important, but it's
[02:45] it's really quite painful. And the other
[02:47] thing is that it's going to really
[02:48] encourage coding work that often times
[02:51] will have a much better um
[02:53] reproducibility framework. So, you know,
[02:56] keep track of your path. Because you're
[02:57] doing it, the computer is doing it and
[02:59] doing it relatively quickly. That's one
[03:00] side. I think for people, I hope people
[03:02] will kind of be excited about this. And
[03:04] then the other for the more skeptical
[03:06] folks, I just want to kind of point out
[03:08] that at the minimum you should know kind
[03:10] of how it works and understand what the
[03:12] capabilities are so you can kind of see
[03:14] where the limits are. I think that's
[03:15] really useful to see um, either as a
[03:18] referee, an advisor, or a co-author, you
[03:20] should be kind of calibrated to what's
[03:22] going on. So, that hopefully you'll find
[03:24] this exciting. I think today in this
[03:26] video
[03:27] if you're a person who's already
[03:28] familiar with Claude code, there's going
[03:30] to be some stuff maybe you listen to us
[03:31] on 2x speed, you know, you figure out
[03:34] until where it's interesting. Uh, this
[03:36] is really going to be kind of setting up
[03:37] and giving core concepts of what's going
[03:39] on and kind of giving an overview. Um,
[03:42] we'll try to go over that and Marcus,
[03:44] you let me know if I missed anything
[03:45] that you think would be important. And
[03:47] then we'll kind of move on in the other
[03:48] videos to just building up. I think
[03:50] videos 1 through 3, if you're kind of
[03:52] new to this, will give you kind of the
[03:53] entryway of seeing how this can work.
[03:56] So, next video we'll start with just a
[03:57] really simple data analysis task where
[03:59] we'll pull data from the web, kind of
[04:01] ask it a question
[04:03] about where data is, we'll pull it from
[04:04] the web, and then we'll we'll make some
[04:06] figures with it that are kind of more
[04:08] than just a simple time series, thinking
[04:10] about um home ownership in the United
[04:12] States.
[04:13] And then the third video we'll think
[04:14] about scraping data from Edgar. So, if
[04:17] you haven't used Edgar before, this is
[04:18] just a database of all filings for
[04:20] public firms, lots of different file
[04:23] forms there. It's kind of very
[04:24] complicated unstructured text data.
[04:27] We're going to just do a particular
[04:28] exercise in it. It will kind of show you
[04:30] how you can do a more complicated data
[04:32] exercise and what you can do.
[04:34] And then we'll talk about big data sets.
[04:37] I think one of the really nice things is
[04:38] that um
[04:40] Claude and other LLMs really can teach
[04:42] you how to work better with big data
[04:45] sets, both in terms of structuring
[04:46] databases, parallelizing, working on
[04:49] clusters, like on the if you have a
[04:51] high-performance cluster that at your
[04:53] university.
[04:54] Um so, that's I think really important.
[04:56] Hopefully, we'll spend a bunch of time
[04:57] there.
[04:58] Uh
[04:59] another kind of side one is about
[05:01] writing and writing like sort of
[05:03] thinking about referee responses and so
[05:05] forth. I just kind of want to show this
[05:07] here, not so much of the idea of oh,
[05:08] this can do all your work for you. I
[05:09] think people are very aware of this for
[05:11] like
[05:12] you can have ChatGPT or something write
[05:14] things for you, but I want to show you I
[05:15] think the key one I'm going to try and
[05:16] show you is
[05:17] one related to the idea of
[05:20] you just got an R&R,
[05:22] you know, the you got a editor letter,
[05:24] you got referee responses. This is
[05:26] really lovely skill that was written up
[05:28] by someone where you can use Claude to
[05:30] go through them and kind of construct a
[05:31] task list of things that you need to do,
[05:33] and um and can really execute, which is
[05:36] pretty pretty remarkable and I think
[05:37] useful for everyone, even if you're not
[05:39] a big coder. Then we'll talk about some
[05:40] customization. This is kind of really ad
[05:42] hoc in terms of things that I've used to
[05:45] make
[05:46] um Claude more useful for myself.
[05:48] And also we'll talk about some of the
[05:49] best practices and get workflows. So for
[05:52] 4 through 7, I think you can mix and
[05:53] match, but we'll kind of try and do
[05:54] those just so that you can have some
[05:56] other extensions and ideas of how to
[05:58] work on stuff.
[05:59] So
[06:01] let's go forward and kind of today what
[06:02] we're going to do in this video is we're
[06:03] going to touch on a number of things.
[06:05] First is just talk about Claude Code,
[06:07] which is going to be the main thing
[06:08] we'll talk about in these videos. And I
[06:09] want to compare it to other tools. And
[06:11] this is really going to be kind of
[06:12] giving you a guideline of what this
[06:13] looks like.
[06:15] We'll kind of briefly go over what the
[06:16] installation looks like. It actually
[06:17] turns out there's not a lot there. It's
[06:19] pretty easy,
[06:21] um which is nice. And we'll talk about
[06:22] what does that entail from a a pricing
[06:24] standpoint like to use it. If you use
[06:26] any If you pay for any AI service, it's
[06:29] kind of comparable. So if you already
[06:30] pay for Claude, you have access to this.
[06:32] Um then we'll talk about the context
[06:34] window, which is an important concept in
[06:35] this. Talk about data and privacy
[06:37] generally, which I know is a thing of
[06:39] people are concerned about. I'll briefly
[06:41] talk about things you can do if you're
[06:43] going to work on the command line to
[06:44] make your life easier. And I'll just
[06:46] kind of end by being like, "Okay, how
[06:47] could one quickly go through this?" And
[06:49] we'll wrap up for today's video.
[06:52] So what is Claude Code? So you might
[06:55] have heard people talk about this. I
[06:57] know people, you know, just refer to
[06:59] Claude. This is just What is this thing
[07:01] that's going on? One way to think about
[07:02] it is it's
[07:04] really kind of an LLM that's running
[07:05] inside your computer. It's on your
[07:07] computer. That's not actually what's
[07:08] going on. It's still going to the
[07:11] internet. But really the one way to
[07:13] think about it is if you've ever seen um
[07:16] you know, videos of the Matrix or
[07:17] something like that, you're kind of
[07:18] typing and and writing all these
[07:20] commands on the on the command line.
[07:22] And it's all these kind of very
[07:24] complicated Unix scripts or other types
[07:26] of things that you need to do. The
[07:28] benefit here is that you open up a a
[07:30] program and instead of having to know
[07:32] all these different scripting languages,
[07:34] you just write in natural English or
[07:36] whatever your preferred language is, and
[07:38] it's going to convert that into code
[07:41] that will do things on your computer. Um
[07:44] it can work on your file system, so it's
[07:46] not like going onto the web. Um
[07:49] really you can think of it as like an RA
[07:50] who's doing stuff for you. So, it can
[07:52] read your code, it can run scripts, it
[07:53] can build things. You're going to talk
[07:55] to it. And the analogy I like to use is
[07:57] that well, what this is when you use the
[08:00] web and you're using these chat programs
[08:01] on the web, this is a lot like
[08:03] exchanging emails with someone very
[08:05] smart. So, if I was trying to get advice
[08:06] from Marcus, you know,
[08:08] uh I'm getting doing emails, I kind of I
[08:10] send something, he has to think about it
[08:12] for a bit, I kind of have to wait for it
[08:13] to come back, I have to sort of be
[08:15] paying attention.
[08:16] Um
[08:17] the benefit, you know, the problem there
[08:19] is sometimes Marcus will ask about
[08:20] something that he doesn't have access to
[08:22] and I forgot to send to him and so
[08:23] forth. Claude code often, you know,
[08:25] it'll be right there.
[08:27] It can write the files, it can pay it
[08:29] can search through files. So, if you've
[08:31] ever had an experience of something like
[08:34] I want to upload a big paper to to
[08:38] something like Claude or ChatGPT to get
[08:39] a summary. Sometimes these files are
[08:41] really big, they're like 100 pages long,
[08:43] very complex. And
[08:46] what the benefit on your computer is
[08:48] that Claude can sort of know that it
[08:50] needs to summarize and search within it
[08:52] because these files are are too big to
[08:53] kind of just read all in one go.
[08:56] So, that's kind of the real benefit of
[08:58] moving to this system. So, you know, one
[09:00] way to think about this is that I've
[09:02] good friend of mine Kyle Jensen has kind
[09:03] of described it this way in a talk that
[09:05] I summarized on my blog if you're
[09:06] interested is like there's this AI, he
[09:09] calls it this path pathway to
[09:11] enlightenment, but these different
[09:12] ladder of where you are. And so, I think
[09:14] a lot of folks are at zero to one. So,
[09:17] they're either using ChatGPT in a
[09:18] browser to kind of co- asking how to
[09:20] code something in ChatGPT, they copy it
[09:22] down, they put it into the editor, then
[09:23] they run that, then there's an error,
[09:25] then they copy it back up, and so on and
[09:27] so forth. Um
[09:29] and level one is something where you
[09:33] have a IDE. So, when I you say IDE, um
[09:36] this is just a an editor, right? So, um,
[09:40] like VS Code, Cursor is another example.
[09:43] I use something called Zed sometimes.
[09:45] Um, these are all ways of editing your
[09:46] code. Um,
[09:48] and what's nice about them is that you
[09:50] can have the LLM's right working in
[09:52] there. So, Copilot, which was very
[09:54] popular program, is the thing that does
[09:56] inline completions and will help write
[09:58] your code. It's really remarkable and is
[09:59] very helpful.
[10:01] You can have a chat with your LLM.
[10:03] It's all kind of embedded in the
[10:05] environment.
[10:06] Um, zero and one is kind of Yeah, go
[10:09] ahead, Marcus. Yeah. What's the
[10:10] Microsoft Copilot?
[10:11] Yeah, so there's a Yeah, VS Code has
[10:13] something called Microsoft Copilot.
[10:15] Yeah, which is coming from
[10:17] um, and that's it's really, uh, you
[10:20] know, Microsoft owns GitHub. GitHub is
[10:21] the one who provides it and so it's all
[10:23] coming They have the same name. It's
[10:24] Copilot. So, there's a Microsoft
[10:26] Copilot, which goes in like when you're
[10:28] in Word or something. Yeah.
[10:30] But that's a distinct one from there's
[10:31] something called GitHub Copilot, which
[10:33] is also owned by Microsoft. But in the
[10:35] end, those are all just using LLM's in
[10:37] the back end and integrating with this
[10:39] this software.
[10:41] The real trick here is that this just
[10:42] uses inline This does like a chat
[10:45] and has inline completions, but it's
[10:47] it's sort of still similar more similar
[10:49] to the ChatGPT in a browser than it is
[10:51] to, um, anything else.
[10:54] Two and three and onwards kind of get
[10:56] more into what people This is what often
[10:58] people call agentic AI. This idea that
[11:01] you have agents, um,
[11:04] that are doing things, that are reading
[11:05] tasks, um, running things, doing things
[11:07] on their own,
[11:09] rather than kind of giving you one
[11:10] response you accept and you go like in
[11:12] the code. It can run its own code. It
[11:14] can search the web in its own way. It
[11:16] can use basically use tools. It's kind
[11:18] of the key thing. So, Cursor, which I
[11:20] think, uh, you said, uh, Ben has talked
[11:23] about, that's a very powerful kind of
[11:26] agentic forward IDE in the sense that it
[11:30] really allows for agents All all of
[11:32] these
[11:33] um editors now to some extent allow
[11:35] agents to work in them.
[11:37] But Cursor is very AI agent forward. And
[11:41] what it means is you can sort of sit
[11:42] there, tell tell your LM to do
[11:44] something, and it will kind of just run
[11:46] all over the screen. It looks like it's
[11:48] kind of running all over the screen
[11:49] doing things. It will edit things. It
[11:50] will kind of look over here. It will
[11:52] read files. You know, you could give it
[11:53] a BibTeX file and
[11:55] tell it to add all these references, for
[11:57] example. But I have I have to ask each
[12:00] and every particular task. So, I have to
[12:02] do or the LM is just
[12:04] >> So, often you'll sort of tell the
[12:06] high-level So, the way that it will work
[12:08] um
[12:09] is that you'll tell it a task, and it
[12:11] will kind of figure out what you're
[12:12] thinking what the tasks need to be, and
[12:14] it will kind of go and do those tasks.
[12:15] So, you'll say, "Update my CV with all
[12:18] the papers that are on my website." It
[12:20] will say, "Okay, first I need to figure
[12:21] out all of the papers that are on
[12:22] Marcus's website." And it will search
[12:24] the web and find your website. It will
[12:26] download those, and then it will
[12:28] dispatch someone to write and update
[12:30] your CV, maybe in in tech in LaTeX, if
[12:33] that's what it is, and it will do that.
[12:35] Um
[12:37] That's kind of This is you know, this is
[12:39] already pretty advanced, and this is
[12:40] this is useful. What has kind of become
[12:42] the new thing that people are using and
[12:44] what we're going to try and push towards
[12:46] today is these dedicated coding agents.
[12:48] So, there's several of them. So, I'm
[12:51] going to talk about Claude Code, but I
[12:52] do hope that people should sort of think
[12:54] about this as being There are many
[12:56] open-source softwares to use this, and
[12:58] we'll talk about Co-worker as well.
[13:00] These are kind of ways of doing kind of
[13:02] you're letting the agents work kind of
[13:05] in these computing environments and
[13:07] doing kind of whatever you allow them to
[13:09] do. So, they can think about a task.
[13:11] They can read files, write files, use
[13:13] tools, execute, create plans, and so
[13:16] forth.
[13:17] Um Codex is kind of the the OpenAI
[13:20] version. Gemini has its own command-line
[13:22] version. Um
[13:24] There are open so There are open-source
[13:27] versions of this. So one is called open
[13:28] code and those let you use different
[13:31] LLMs in the back end. Um
[13:33] So this is they're all programs. The way
[13:36] that you should think about this and
[13:37] we've is that they're all programs that
[13:40] use LLMs in the cloud in some sense or
[13:44] you know, they're using an LLM. So
[13:47] they're kind of like harnesses that sit
[13:48] on top of whatever the machinery is. So
[13:50] or the you know, whatever the horse is.
[13:52] So what's the exact what are they doing
[13:54] in three? I mean in two I employ a bunch
[13:57] of agents to do something that might
[13:58] even interact with each other.
[13:59] >> Two is really going to be within um it's
[14:02] exclusively within an editor. And so
[14:04] kind of the key distinction here is that
[14:07] um
[14:09] it is they're going to be very similar.
[14:11] I think the the boundary between two and
[14:13] three sometimes is not going to be and
[14:14] so you know, Claude co-work in some ways
[14:16] is going to be closer to two than to
[14:18] three.
[14:19] Um the main way that kind of that this
[14:22] changes is that often Claude co-work and
[14:25] these other ones here, you can actually
[14:27] improve them significantly. They can
[14:29] really So
[14:30] the boundary between these two is pretty
[14:32] small in some ways, but the main way is
[14:34] and we'll talk about this in I think
[14:35] video seven where you can really improve
[14:40] the agent itself
[14:42] through updates to either what are
[14:44] called skills or it's it's kind of
[14:47] memory bank. So it's not actually
[14:48] memory, but you keep track of a file
[14:50] which says this is what I'm going to do.
[14:52] That can happen inside these agent modes
[14:54] that these kind of these harnesses all
[14:57] are kind of much more structured to do
[14:59] that kind of work. So
[15:01] I think this is you know, like all
[15:03] ontologies, this is this you know, the
[15:05] the metaphor breaks down eventually.
[15:07] And the kind of key reason why you
[15:10] always have to keep this in mind is that
[15:11] in the end they're all using the same
[15:12] LLMs. And we'll talk about like what
[15:14] these are doing, but LLMs in the end are
[15:16] generative AI models.
[15:19] You can only you know, slice up an AI
[15:21] model so many ways before it's the same
[15:23] idea going on, but you're adding kind of
[15:24] new new tools to it and everyone.
[15:27] I don't want to belabor the rest, but
[15:29] kind of
[15:30] four is a way of adding more tools,
[15:32] often through something called MCPs, to
[15:33] kind of improve and orchestrate how it's
[15:35] working. And five is like you basically
[15:38] create this container where you tell it
[15:40] what it's there and you let it go for an
[15:42] hour and a half by itself and it just
[15:43] works itself to completion. And that's
[15:46] kind of way beyond what we'll do, but we
[15:48] can talk about this at the end of the
[15:49] video series of what one When people
[15:51] post on social media, like, "Oh, AI
[15:54] wrote, you know, a whole paper for me in
[15:56] an half hour" or something, they're
[15:57] really referring to cases like this.
[16:00] Um but it's not inherently like
[16:02] necessarily better, but it just kind of
[16:04] you There's a lot more setup involved in
[16:06] it.
[16:07] So, let's kind of talk about what these
[16:09] are before and then just so that people
[16:11] can kind of get a sense is that
[16:13] I've mentioned a lot Claude Code.
[16:15] There's also Claude Co-work. There's
[16:17] Cursor and and Co-pilot and these other
[16:20] IDE-based ones. Zed AI is another. This
[16:24] is another basically actually Zed
[16:25] typically the the main one is Claude
[16:27] that's in there. These two here are
[16:29] IDEs. Um
[16:32] they are mainly This is so they're
[16:34] they're the level two that we talked
[16:36] about. Claude Code and Claude Co-work
[16:38] are kind of Claude Code is very much
[16:41] level three um and onwards. Claude Code
[16:44] is kind of floating betw- in the between
[16:45] the boundaries of one through three,
[16:47] depending on how you think about it. Um
[16:50] Let me start by saying what Claude Code
[16:52] is, just in case that like people
[16:54] haven't seen it yet and they say, "No."
[16:56] is and you know, I've shown Marcus this
[16:57] is like, you know,
[16:59] Claude Code, you're really sitting at a
[17:00] terminal. You really feel like,
[17:02] depending on your age, you're either
[17:04] somebody in the Matrix or, you know,
[17:05] Marcus was joking about his age is you
[17:07] feel like you're 30 years ago and you're
[17:08] back in the computing lab kind of
[17:10] situation. It's you're at MS-DOS and
[17:12] you're kind of remembering what commands
[17:14] are.
[17:15] Um the joke, of course, there is that
[17:16] like
[17:17] the whole point is that you don't have
[17:19] to do much on your own if you trust
[17:20] Claude code is that you just open it and
[17:22] it will do all the kind of matrix style
[17:25] coding, but it helps to be at least a
[17:28] little bit comfortable with the terminal
[17:29] for that reason. Um, what that will do
[17:31] is it can kind of let what's really
[17:33] powerful there is it lets you
[17:36] see your whole file system. You can
[17:39] um use bash commands, which is part of
[17:41] the shell script. This is the types of
[17:42] command. It is kind of a brainiac when
[17:44] it comes to shell commands and so it can
[17:46] do all this amazing stuff like kind of
[17:48] the best programmer.
[17:50] It's able to run scripts, install
[17:52] things, use get, um, do a lot of stuff
[17:55] in here. It's really like the closest
[17:57] thing to when you're running a real full
[17:59] program um or full project. That's what
[18:01] you want to be doing.
[18:03] Co-work, let me just kind of contrast
[18:05] that with co-work cuz I think um when
[18:07] Marcus and I have talked about this is
[18:08] kind of a really nice if you're really
[18:10] kind of not comfortable, you don't want
[18:11] to be on the command line. This is a
[18:13] nice entryway. I would not encourage
[18:15] this for full time.
[18:17] Um
[18:18] It's it's an app that sits on your
[18:19] computer. You download it. I'll show you
[18:21] in just a second how to do this, but it
[18:22] it's really a web browser a little bit.
[18:24] You're sort of kind of running it's just
[18:26] a Chrome port, I think um a chromium
[18:28] port.
[18:29] But it's like the web browser in there.
[18:31] It's on your computer though. It has
[18:33] access to your computer. You tell it
[18:35] what you want to use and it's going to
[18:36] be very sandboxed in what it does. Um,
[18:38] we talked about this in video seven.
[18:40] Sandboxing means like you're restricting
[18:42] what it can do and we'll talk about one
[18:44] challenge there is that it restricts
[18:46] your access to the internet. You can
[18:47] kind of do things to allow it to get
[18:49] access, but it's still going to be it's
[18:51] not going to be nearly as autonomous as
[18:53] Claude code is, but that has benefits
[18:55] because it's not as risky. Um, I think
[18:58] this is good if you're this is sort of
[18:59] similar if you're using a chat or if you
[19:00] want to do quick exploration with your
[19:03] stuff on your computer. This is great,
[19:05] but it's not really the full coding um
[19:07] stack in the same way.
[19:09] And then I think you've already talked a
[19:10] little bit with Ben about cursor and
[19:12] these other things, so I don't want to
[19:12] belabor it, but this is kind of more of
[19:15] like I'm using Claude code in the things
[19:16] that are open inside my IDE. That's kind
[19:19] of like then I can use Claude in various
[19:21] things within those open ones, but it
[19:22] kind of doesn't have full access to
[19:24] everything that's there or kind of
[19:25] access to kind of bash commands and
[19:28] everything else. The boundary is a
[19:29] little permeable in the sense that if
[19:31] I'm running Claude inside Zed, it could
[19:34] do stuff locally. This is not like Mhm.
[19:37] So, there's an app I just think that
[19:39] like
[19:40] really one way to think about this is
[19:42] that Claude
[19:44] code is kind of a version of what runs
[19:46] inside this, but it's kind of full uh
[19:48] more fully uh more oops, sorry, more
[19:50] fully operationalized.
[19:52] So,
[19:53] um I'm going to focus most on this um
[19:58] on Claude code just cuz I think it's
[19:59] with the closest to research workflows,
[20:01] but it's not exclusively that. So, the
[20:03] one comment I made and Marcus and I have
[20:05] talked about this is that in Claude
[20:06] co-work, it's very sandboxed, so it
[20:10] can't like run Python scripts to scrape
[20:12] the internet. Um we talked to Claude
[20:15] about what you can do, and it turns out
[20:17] um you know, there's a thing you can do.
[20:19] You can fix it. So,
[20:21] inside Claude code, there there's the
[20:24] desktop app or on the website, you can
[20:26] just go and allow it to access the
[20:28] internet and you kind of have to be
[20:31] permissive about what you let in and
[20:32] out.
[20:34] It's um Claude co-work. Co-work.
[20:36] Co-work. This is co-work. Yes, exactly.
[20:38] So, desk Claude desktop is Claude
[20:40] co-work. When you download something
[20:41] Claude Claude desktop, it has the chat,
[20:44] co-work, and something called Claude
[20:46] code as well, which is a version of
[20:47] basically um co-work, but using Git. Um
[20:56] The trick here is you can do things to
[20:58] allow it to be permissible. Mhm. The
[21:00] challenge here, and we talked about this
[21:02] a little Marcus, is that like
[21:04] there are some potentially some bugs
[21:05] here. I think this will all kind of get
[21:07] fixed up. This is probably a very
[21:08] reasonable way to approach these things,
[21:10] but it's not going to be kind of as um
[21:13] incredibly powerful out of the box. You
[21:16] kind of have to do more things, but if
[21:17] you're kind of risk-averse, this might
[21:18] be the thing that you like because in
[21:20] some ways I just wouldn't update too
[21:22] much about AI don't use this and then
[21:24] like not be able to do stuff and say,
[21:25] "Oh, AI is not that powerful." I think
[21:27] one way to think about this is like this
[21:29] is you taking LLMs and put a lot of um
[21:31] put a lot of uh what's it called? Um
[21:35] restrictions on it. So, that that's with
[21:37] the purpose. Code works still goes to
[21:38] the internet like chat?
[21:41] Yes, but it has a very um yes, so the
[21:43] way that it does it just that not to get
[21:44] into details is that it
[21:46] restricts very much what IP addresses it
[21:48] can get to. So, it Claude Claude Code
[21:51] work very much has to query Anthropic to
[21:53] get the LLM responses. Yes. But
[21:57] it has a very restricted way in which it
[21:58] can query the internet. And so, you have
[22:00] to kind of manage what it's allowed to
[22:01] do.
[22:02] I see.
[22:03] That's not the case for Claude Code by
[22:05] default.
[22:07] Okay. So, let me just quickly say like
[22:09] what does it mean to install it? Um
[22:12] you're basically going to search
[22:14] uh
[22:15] um Claude Code
[22:16] >> now? This is either I'll show you this.
[22:18] This is for Claude Code what you'd do.
[22:20] You can either you would just go this
[22:22] and you go to the command line and you
[22:24] would copy this one line. So, you'd open
[22:25] terminal and you'd copy this one line
[22:28] and you'd install it.
[22:30] There's a even a web a guide here. It's
[22:32] new to the terminal see the terminal
[22:33] guide for step-by-step instructions.
[22:36] Alternatively, if you want to download
[22:37] Code work, you're going to search
[22:39] download Code work and there'll be
[22:40] you'll choose choose one of these two
[22:42] and it will be there directly. So, the
[22:44] neither of these
[22:45] in some ways we should not belabor the
[22:46] installation because it is about as
[22:48] user-friendly as it can get.
[22:50] Um
[22:52] Last thing is in terms of costs. Um
[22:55] there's three levels. There's Pro, Max,
[22:58] and Max 20X.
[23:00] Um Pro, if you're using Claude chat
[23:03] functionality online and you're paying
[23:05] for it, this is almost certainly what
[23:06] you're using.
[23:08] Um,
[23:09] this is what I would start with if you
[23:10] want to try this out. I think it's
[23:11] great. If you're not a heavy user yet,
[23:14] it will get you started and you can see
[23:15] what's possible. I pay for the max, but
[23:18] that's in part because I use this
[23:20] huge amount.
[23:22] Um, there are ways to use the API to do
[23:24] things. So, the API means it is like a
[23:26] paper paper use.
[23:28] That's not really what I would do for
[23:31] this that the real kind of default view
[23:33] is that the subscriptions are heavily
[23:35] cross-subsidized in some ways that these
[23:37] are kind of
[23:39] these are really useful for the most
[23:40] part. Um, so I would start with either
[23:43] the 20 or the $100 one. I I don't think
[23:45] you need to move to the 200 um, at all.
[23:47] And that's true for Cohere as well. So,
[23:49] like I think you need at least 20 to be
[23:51] able to use Cohere um, locally.
[23:54] So, let me quickly um, talk about kind
[23:57] of the underlying key concept which is
[23:58] the context window. Um, I think, you
[24:01] know, people seeing this have started to
[24:02] hear this, but like
[24:04] you're going to see something which is
[24:06] going to be you're going to talk to the
[24:07] LLM, you'll see a response, you you
[24:09] know, write things, you'll see a
[24:10] response back and forth. But there's a
[24:11] lot of things there that you don't see.
[24:13] And so, what that looks like is like
[24:16] this. So,
[24:17] you know, this is what an LLM chat looks
[24:19] like. You have some prompt at the
[24:20] beginning
[24:21] which you don't see, which is called the
[24:23] system prompt. This is with ChatGPT, an
[24:25] example.
[24:26] It has all this information about things
[24:28] you can do. It has a developer message
[24:30] about what it should do. Then you see
[24:32] your question. So, it says, "What's new
[24:35] in the latest versions of Polaris?" And
[24:37] then there's a lot of thinking stuff and
[24:38] tool calls that it does. Finally, it it
[24:41] prints some results to itself.
[24:43] And then it has a response that it does
[24:45] in in response to it. Typically, you're
[24:47] only going to see the green part and
[24:49] this black part here. Sometimes,
[24:51] depending on how they do it, they'll
[24:52] talk about the thinking. They'll you can
[24:54] click on a thing, you can say, "Oh, it's
[24:55] thinking." And you click on what it's
[24:57] saying, and it will write this stuff.
[24:59] But what's important to notice is that
[25:01] if I continue this conversation, all of
[25:03] this chat will continue will be sent
[25:05] back. Every time it's sent,
[25:08] every time you query it, you send the
[25:10] whole thing back. It's so it's a cached
[25:12] message. And so,
[25:15] one way to think about it is that every
[25:17] time you say something, all of these
[25:19] things are appended together. When it
[25:21] reads a document, when it responds
[25:22] something. So, say you went down a
[25:24] rabbit hole and you spent, you know, 10
[25:26] minutes about something ridiculous
[25:28] that's irrelevant, all of that's getting
[25:30] sent back and forth.
[25:31] And so, kind of a key idea behind
[25:34] this is something called context
[25:36] engineering. So,
[25:38] there's this idea that it's sort of
[25:39] similar to when people talk about prompt
[25:41] engineering.
[25:42] You know, as you go along, there's all
[25:44] this work that that's kind of like, you
[25:46] know, like you're working on a proof
[25:48] markers or something. You have all this
[25:49] scratch paper which you do. And
[25:50] eventually, you're like, "Okay, let me
[25:52] take all these ideas and kind of write
[25:53] it very concisely on one piece of
[25:55] paper." Part of the reason is that you
[25:57] kind of have lost track of all the like
[25:59] things you care about in this.
[26:01] And so, what you'll And so, the you
[26:05] know, the idea that people say here is
[26:06] that kind of as you go longer and
[26:09] longer, the performance degrades. People
[26:10] say that kind of like
[26:12] as the size increases, performance
[26:14] declines. And kind of the more precise
[26:16] you are, kind of performance increases.
[26:19] So, it's this idea of the per- more
[26:20] precise you are in these things, the
[26:22] kind of better performance will be, but
[26:24] the longer it goes, the kind of worse it
[26:26] will be. And so, the the typical thing
[26:28] that people try to say is to
[26:31] um if as you get longer and longer, the
[26:34] LLM will eventually say, "Hey, I can't
[26:36] keep track of all of this. Let's
[26:38] basically make a memory. So, let's like
[26:41] write all Take everything we did and
[26:42] kind of summarize it." That's when it it
[26:45] will say something like on on a website
[26:47] on the the website, it will simply
[26:49] typically say something like, "Oh, you
[26:51] need to start a new chat."
[26:53] On Claude Code or on Claude Co-work, it
[26:55] will say, "Oh, I'm going to compact
[26:57] what's going on." And so, it will take
[26:59] all of this, it will make a memory, and
[27:00] then it will kind of embed this on here.
[27:03] And
[27:04] um
[27:05] what's better like the brain when you
[27:07] sleep, no, it also
[27:08] >> Exactly, exactly. I mean, this is
[27:10] the analogy, it's very hard to not
[27:12] anthropomorphize these things. I mean,
[27:14] these are There's reasons why these make
[27:15] sense as concepts. Um
[27:17] uh it's not exactly the same, but of
[27:20] course, it's similar. So, typically the
[27:22] way that people talk about improving
[27:23] this is being kind of explicit in the
[27:26] way that you do this. So, what you do is
[27:28] you first start by doing, "Okay, I'm
[27:30] going to think about this. I'm going to
[27:31] do some research. That's like my
[27:32] research thing. I'm going to do this.
[27:33] I'll have an idea." And then I'm going
[27:34] to say, "Okay,
[27:36] summarize all this and write it down in
[27:37] a file. Let's call it our research
[27:39] file."
[27:40] And then I'll say, "Okay, like given
[27:42] that, you know, summarize the things in
[27:44] particular that I wanted." Then I'll
[27:45] say, "All right, I'm going to start a
[27:46] new conversation.
[27:48] Read this research file, and now I want
[27:50] to make a plan of how to implement this.
[27:51] Blah blah blah blah blah. Let's do that.
[27:53] Now, write that plan to a file. Okay,
[27:56] I'll clear everything out. Now, I'm
[27:57] going to read the plan, and I'm going to
[27:58] get started."
[28:00] And this is kind of a way of kind of
[28:01] explicitly trying to be um purposeful in
[28:05] the way you do this. Now, what I'll say
[28:07] 2 months ago, 3 months ago, this was the
[28:09] way to do everything 2 months ago.
[28:12] Now, these things have gotten a lot
[28:14] better. Claude Code and these others
[28:15] they kind of know, they're much more
[28:17] intentional and better at how to compact
[28:19] things.
[28:20] This matters a little bit less, but this
[28:22] idea of break things into kind of
[28:24] actionable tasks is a really important
[28:26] concept.
[28:27] Can I guide it somehow what to memorize
[28:30] and how to start
[28:31] >> Yes.
[28:32] Yes, so when you're in this, you can
[28:33] write something called compact. So,
[28:35] there's a a skill or a command called
[28:37] compact, and you could say like, for
[28:39] example, imagine you did a bunch of
[28:40] research, you could say
[28:42] "Compact um uh
[28:44] remember let remember all the things
[28:46] related to
[28:48] um
[28:49] you know the
[28:51] you know non-linear programming that we
[28:52] just study like that we just focused on
[28:54] and it will then kind of in the thing
[28:56] that it compacts to here these memories
[28:58] it will be guided in the way that it
[29:00] does that as well.
[29:01] So it yeah it can be very explicit. So
[29:03] kind of the key way to think about this
[29:04] is the context window is kind of the
[29:05] shared resource everything you do
[29:08] takes it and so basically it's kind of
[29:09] like
[29:10] if you come to a meeting unprepared and
[29:12] kind of vague you spend a lot more time
[29:14] spinning your wheels. If you're focused
[29:17] and prepared that works much better and
[29:19] so kind of the idea is if say you feel
[29:21] unfocused it's better to kind of think
[29:23] for a bit with the LLM then you have
[29:26] your ideas settled you write those down
[29:28] and then you start a new session with
[29:29] those ideas.
[29:31] Okay. Let me Let me quickly talk about
[29:33] privacy.
[29:35] So this is something we've talked about
[29:36] is that now that we've talked about what
[29:38] Anthropic is seeing well when you do
[29:40] tool calls it's calling your data and
[29:42] like looking at it or it's reading
[29:44] what's going on and so there is an
[29:46] extent to which
[29:48] Claude code doesn't copy things to your
[29:50] server but
[29:52] your conversation is going there right
[29:55] it's reading stuff and going to the API.
[29:58] So this is the same as going on the
[30:00] website and pasting stuff in and you
[30:03] know they claim they're not training on
[30:04] the data.
[30:05] I will just say that like you know take
[30:08] that as you will and [snorts] it's of
[30:10] course these AI companies all have
[30:12] different views and different things and
[30:14] they say you know what's legal and
[30:16] what's not. So I would say be careful on
[30:19] things like this. I think this is an
[30:21] extent to which it's something you keep
[30:22] on Dropbox or Google Drive I think this
[30:25] is sort of risks are similar in terms of
[30:26] risk profile
[30:28] but
[30:29] um you know that's kind of the boundary.
[30:31] If it's something that is kind of
[30:32] uh you would need to be worried about
[30:34] that's you know something with IRB data
[30:36] for example I would wall that off in
[30:37] some way I would think about making sure
[30:39] like
[30:40] I What I mean by that if it's like um
[30:41] PII data that you really have to keep on
[30:43] like a HIPAA compliant server.
[30:47] You really should be not necessarily
[30:49] running it there. You should like have a
[30:51] different way of doing it. Try not to
[30:53] put in all your API keys or passwords.
[30:55] If you accidentally paste stuff into
[30:56] Claude, often it will say, "Hey, that's
[30:58] an API key. Don't do that. You need to
[31:00] delete that and start a new get make a
[31:02] new password." Um
[31:05] But it's just something to keep in mind
[31:06] that like
[31:08] there it's very much a thing that's
[31:09] there in the future I'll kind of talk
[31:11] about how to sandbox in a way that's
[31:13] similar to what co-work does, but you
[31:14] can have a lot of control over it and
[31:15] mount only the drives that you're
[31:17] interested in.
[31:18] Um I think in the interest of time we
[31:21] can kind of defer this a little bit to
[31:22] the just the slides that we'll post
[31:24] Marcus, but I just want to highlight
[31:26] that if you're a a person who wants to
[31:28] use the terminal, there's lots of nice
[31:30] ways to make the terminal look better.
[31:32] When you see in future videos, I'm going
[31:33] to be using something called Ghosty or
[31:35] Zellij, which are just ways of making it
[31:37] look better.
[31:39] Um
[31:40] And also ways of improving kind of your
[31:42] bash your basically your shell. I use
[31:45] something called Oh My Zsh, which is
[31:47] quite nice and just makes it a little
[31:48] friendlier, but none of these are
[31:50] requirements or policies.
[31:51] >> What is a shell thing different from the
[31:53] previous slide? So a shell is the shell
[31:56] is the underlying commands where you run
[31:58] things. So when you say something like
[31:59] CD for change directory, that's called a
[32:01] shell command and you're executing it.
[32:04] It's so Zsh or bash are two types of
[32:08] programs that run on either Unix or
[32:11] Linux or
[32:13] on a Mac.
[32:15] Windows doesn't use those, they use
[32:16] something else. Okay, so basically in
[32:18] terms of thinking about just to kind of
[32:20] sum up, if you want to you know, if you
[32:22] don't watch the next video and you want
[32:23] to just get started right away, things
[32:25] are just some tips to get started would
[32:27] be you know, be specific. I think it's
[32:29] helpful to kind of the same way that you
[32:30] tell an RA about how to be specific,
[32:32] you'd say, "No say analyze this data."
[32:35] It's going to say, "What data is it
[32:36] talking about? I'm going to look at all
[32:37] these CSVs." You could say, "I want you
[32:39] to load this file, calculate monthly
[32:41] growth rates by sector, and plot it at
[32:42] plot a time series of it."
[32:45] Um second, I would say like, you should
[32:46] iterate. You can do things, but don't
[32:48] necessarily argue with it. It's really
[32:50] kind of a waste. Um you know, saying
[32:52] something like, "Okay, take that graph
[32:53] and make the legend larger." That's
[32:55] fine.
[32:56] But, you know, if Claude is going in
[32:58] circles, I would cancel. So, typically
[33:00] in Claude code, that would be hitting
[33:01] escape to to interrupt it.
[33:04] And you can actually go back. Um you can
[33:06] hit escape again and go back in the
[33:08] context window to where you started and
[33:10] you said like, "Okay, this wasn't clear
[33:11] enough. Forget everything we just did
[33:12] for the last 2 minutes. Let's start
[33:14] again."
[33:16] I would make sure to like catch it early
[33:18] to tell what to do. If you start seeing
[33:20] it use something like Python instead of
[33:22] R or using R instead of Stata or what
[33:24] have you, you know, interrupt, tell it,
[33:27] and then say, "All right, keep going."
[33:28] It will fix itself.
[33:30] And I would, you know, trust what it's
[33:32] doing, but I would verify. I think it's
[33:33] very good. Like, it's a remarkable
[33:35] program
[33:36] um programmer, but it will make
[33:38] mistakes. And so, you know, you want to
[33:40] be kind of careful with edge cases is
[33:42] kind of the key thing. Like,
[33:44] you know, it's going to do stuff, but
[33:46] it's going to be very confident. So, you
[33:47] it definitely have to verify. Like, this
[33:49] is not a
[33:50] We'll talk about ways in which,
[33:51] especially from a data standpoint, you
[33:52] want to structure things so that you can
[33:54] easily check stuff. It's the same way if
[33:55] you have an RA work for you. You know,
[33:57] an RA can make stuff. You still have to,
[33:59] you know, it's going to be your work
[34:01] eventually. You have to trust it and
[34:02] verify in a number of ways.
[34:04] Okay, but when I want to use R or
[34:06] Python, I have to download it first, no?
[34:08] Yes, and it can do that for you or you
[34:10] can it can do the installation for you
[34:12] or
[34:13] um
[34:14] you can do it beforehand. That's one
[34:15] nice thing of using Claude code instead
[34:17] of something that's sandboxed like
[34:18] Claude co-work is that it's all in
[34:20] there. You are it's everything you
[34:21] already use. So, if you don't if, you
[34:23] know, say you use MATLAB instead, you
[34:25] say do it in MATLAB or whatever. Kind of
[34:27] it's irrelevant.
[34:28] >> But, it doesn't use some
[34:29] R in the cloud or something or Python
[34:32] >> No, it doesn't write on your computer.
[34:33] Okay. Yeah.
[34:36] So, let me kind of sum up um you know,
[34:38] what we covered. We talked about the
[34:40] different types of um ways that you can
[34:42] use things. So, Claude Code, which is
[34:44] you know, in your terminal, has full
[34:46] access to everything, your shell.
[34:49] We kind of contrasted this with other
[34:51] types of agentic things that you can
[34:52] use. Claude Co-work, which is this
[34:54] sandbox web environment, has sort of
[34:56] more limited access, um sort of more
[34:59] limited tools, but also it's going to be
[35:00] a much better entry point. And then
[35:02] these agentic um
[35:04] IDEs, like Cursor, which run inside the
[35:07] IDE, but are kind of access to files
[35:09] that are open inside it. But then the
[35:11] boundary's a little blurry there, but
[35:12] that's kind of a good way to think about
[35:13] it. Talk about how installation is very
[35:15] easy. It's kind of if you're already
[35:17] paying $20 a month, you should try it
[35:19] out right now.
[35:20] Talked about the context window. Talked
[35:22] about data privacy. I view it as kind of
[35:24] comparable to Dropbox, but you know,
[35:26] your mileage may vary. And we talked
[35:28] about what you do. I think the basic
[35:30] loop, you should think about it as
[35:31] describe what you want. Claude will
[35:33] write write and run code, and then
[35:34] you'll iterate on it subsequently. And
[35:36] what we're going to do next video is
[35:38] we're just going to talk about how we
[35:39] can do it. We can get some data from the
[35:41] web. We'll make a graph
[35:43] out of it, and we'll sort of see how we
[35:44] can make some really kind of interesting
[35:45] stuff, even if you don't really have an
[35:48] idea of where the stuff comes from. And
[35:49] so, it it kind of can be really
[35:51] powerful. So, with that, um
[35:54] we can stop right there. Thanks a lot,
[35:56] Paul. So, we're looking forward to the
[35:58] next
[35:59] little video
[36:00] to get really accustomed with all this
[36:02] Claude Code and Claude Co-work and
[36:04] whatever we can learn from you. Thanks.
[36:06] Great. All right, wonderful. Thanks for
[36:08] joining.
[36:10] Bye-bye.
[36:11] Bye.
[36:27] >> Mhm.