# Skills: Claude Code for Economists with Paul Goldsmith-Pinkham | Markus Academy | Ep. 162-6

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

[00:08] Welcome back to Claude AI for applied economists.
[00:11] Another mini video of our mini video series, how to use Claude AI for economists with Paul Goldsmith Pincom.
[00:17] Hi Paul.
[00:19] Hi.
[00:22] So today we will actually talk about making skills.
[00:24] We go deeper into making skills.
[00:26] So Paul, we are waiting for your
[00:34] Great.
[00:37] Yes, so let me share this.
[00:39] I'm going to do a little bit with some slides today and then we'll get into full on command line thinking about code again.
[00:43] But you know, we talked a little bit Marcus about skills in other videos.
[00:45] We talked about We we show I talked to you about a skill that you can use for thinking about referee revisions.
[00:48] I also talked about a skill that you can make about your writing and other sorts of things.
[00:51] Today I wanted to just spend a little bit of time for this not too long of just trying to make sure
[01:08] that everybody kind of understands how skills work when what's going on.
[01:11] I've kind of touched on some of these ideas, but I wanted to go over it.
[01:15] And so really skills at the super high level is you are kind of giving a a broad plan specifying how these agents, how these LLM's should think about a problem.
[01:26] And so one idea of if you want to give context to it, a skill is kind of reusable instruction bundle.
[01:33] So the text that you're going to put in there as we've looked over it, it's kind of just a long prompt, like the kind of thing that you would write out if you were describing something to Claude.
[01:42] But it just gets all put into one file in a way that when that gets executed the whole thing happens.
[01:48] And what's of course what's interesting about that is there's a couple of different ways in which that can be executed, which we'll talk about.
[01:55] But really the idea is that instead of having to re-explain the same task every time, you kind of encode what you think of the task, how you should structure the output, and then what you need to check while you do it.
[02:05] And so, it's really In my mind, this is not my own um
[02:11] language to use it.
[02:12] There's a a great commentator on Substack who said this is that skills are a way of trying to specify how an agent should think.
[02:16] Cuz there's a little bit as you start to make um explicit how you want to think about a problem, you're kind of it'll elaborating the steps.
[02:25] So, in research, of course, right?
[02:27] Like, how do you want to summarize a paper?
[02:29] What are the things that you want to focus on?
[02:29] You know, if you were drafting referee report comments, if you wanted to diagnose certain things, do a literature review.
[02:36] For example, right?
[02:38] If you had an RA and you want them to do a uh literature review, you might have a very explicit set of steps on how you want them to do it.
[02:44] You may do that the first time you describe it to Claude, but then, of course, you might want to say, "Look, every time I want you to go search these X journals, look for all the words, find all the papers, then look at all the papers they cite related to this topic, and go and so on and so forth."
[03:00] And the nice part about skills is that's all going to be encoded into just one thing, and you won't have to re-explain yourself each time.
[03:08] So, that's just really it's a standardization.
[03:09] It kind of doesn't do
[03:11] anything beyond that.
[03:13] It's not a power, it's nothing um addition, it's just a way of improving um thinking.
[03:18] And so, I Before we get into like exactly what it is, and we're going to make another one, just kind of what we talked about last time, and then we'll go over a few examples is I just One thing that people always find a little confusing is kind of what the skill like where are the skills?
[03:32] And we looked at some of them together because we made some of them, but I want to kind of give you a sense of how Claude code and many of the other coding harnesses think about this.
[03:40] So, um there's really two ways in which Claude files get stored.
[03:45] So, there So, well, actually, let me start by saying every skill is just a folder.
[03:56] So, inside the skills folder there is a folder, for example, called paper summary.
[04:01] That's like the one that we'll make today where it has three things.
[04:05] So, well, actually really just has one thing.
[04:07] It has a skill.md file.
[04:09] So, the name of it is based off the folder and the file is always going to
[04:12] be called skill.md.
[04:14] That's going to have what the instruction is like for the prompt.
[04:17] And then it might have some additional things that you need to use.
[04:18] But, that's always just going to So, you're going to have just a bunch of folders.
[04:21] If you have a bunch of skills, you have a bunch of folders.
[04:26] And then there's two ways they can be installed.
[04:27] So, um the thing can either be installed globally.
[04:31] So, when I say something is global, Marcus, what I mean by that is that in any project that you use it in, that skill is always available.
[04:43] Mhm.
[04:44] So, you know, it's where it would get stored is in your user folder.
[04:46] So, the tilde in Mac and uh Unix-based uh this just means like the the person's personal folder.
[04:53] There's a file folder called .Claude.
[04:58] And the reason there's a dot there is cuz it means it ends up being hidden.
[05:00] Um so, you don't typically see it.
[05:04] It doesn't make a a big mess in your folders.
[05:05] And then there's a skills folder.
[05:07] So, that's for every project.
[05:13] if you don't want it in every project,
[05:14] like for example, you might not need this in every folder.
[05:18] Um you can have it instead in whatever folder that you're working in.
[05:25] So, typically that would be like a repository for me, you would have a .Claude folder.
[05:28] So, you can have two levels.
[05:29] You can have a project level one, which would be in the main folder that you're in, and then one at the user level.
[05:35] Now, it's kind of useful.
[05:37] You might be asking yourself, Marcus, maybe maybe not, but I'll pretend that you are, which is that why would I never want it at the user level?
[05:47] Why wouldn't I just want access to all my skills all the time?
[05:52] And so there's kind of two reasons they're related.
[05:56] One reason is that um skills take up a little bit of space.
[06:03] So in to some extent remember that we're thinking about an LLM as as kind of a lot of content.
[06:06] There's a right it's just about the context window and the information that's there.
[06:09] When you have skills
[06:13] information about the skills not the whole skill, but information about the skill is embedded in the initial prompt.
[06:20] Specifically the information that knows the description about when it should be used.
[06:26] So a skill that we'll look through at the beginning it has a name and a description.
[06:30] Mhm.
[06:30] And in the description there's going to be something that says like when you're summarizing a paper you should use this skill.
[06:38] That's just going to be additional information of course if you have a thousand skills, that's just a bunch of stuff that has to get loaded up every time.
[06:43] So think about it like when you reboot your computer if there's a bunch of things that have to open up every time you do it it's kind of slow when you start it up.
[06:51] Um the second thing is um you may just not want it to do certain skills in certain time periods.
[06:58] Right?
[07:00] If you're doing something new you may not want access to that particular skill.
[07:03] So that's just sort of useful.
[07:05] I actually install very few things at the global level but just something worth keeping in mind.
[07:11] So it's really easy in some ways
[07:14] So the project here is called project this called skills or there's another side.
[07:16] Oh no, no, the project would be like you're in a folder.
[07:19] So what I mean by that is like say we're in one of your folders like you know macro macro finance paper X and then this would just be at that at the top level.
[07:30] And so there'd be a folder called dot Claude in that folder.
[07:34] So how would we make a skill?
[07:36] So the way that we're going to do this first is I'm going to we're just going to make one so we can remind ourselves what it looks like.
[07:40] Um we want to have a task where we potentially keep giving the same instructions.
[07:44] We're going to think about what the inputs are, what the output that we want, and then we're going to write the instructions.
[07:49] Now, you can actually write it yourself in words, but as with many of these things with these AI agents, it's much um more practical to have the AI make a first pass at what the instruction thing looks like and then edit accordingly.
[08:07] Um, this is kind of the the most uh the null version of a skill.
[08:11] It's the thing that we used before, but it's kind of a very simple way of uh re-implementing things.
[08:16] So, let's do an example just to kind of make life easy.
[08:21] Um, we are going to think about something that's going to say, "Look, I have a seminar visitor coming or I'm visiting someone for a seminar.
[08:30] I want to be able to look at some of their papers and just have some notes on kind of the headline things.
[08:33] So, this would be for an empirical paper.
[08:34] We can edit this accordingly.
[08:35] Um, but it's was sort of a way to prep or do sort of a lit- literature review.
[08:40] And the nice way to do this you might be just like, "Here's a link to a paper.
[08:43] Um, go do accordingly."
[08:45] Or here's the here's the PDF.
[08:49] So, I'll show you how we're going to do this um and then we can and then we can walk through an example.
[08:52] Okay, great.
[08:56] So, now what we're going to do, so usually if we were, you know, if we were doing something in Claude, we could very easily, you know, just say once we're done with the task and we realize we like a skill, we say, "Let's build a skill based off of this."
[09:08] Of course, you and I are doing this sort of artificially.
[09:12] And so, what we'll do is we are going to just build something directly.
[09:14] We're
[09:16] Going to say, "All right, how can we um I want to build, I'm going to say something along the lines of, "I want to make a skill for this directory um that summarizes academic economic research papers um for when I am visiting other departments or when some of our visitors are visiting me."
[09:45] The input of the skill should be either the URL for a PDF or a file path for the PDF.
[09:55] The more specific we are, remember, the better.
[10:00] Um the output should have something as follows.
[10:08] So.
[10:14] And we can decide if we are we're happy with this.
[10:17] Um so you you and I can iterate on this.
[10:22] Okay.
[10:23] Let's actually, you know what, before we do this, let's actually say what we want to do is the um the output should be in a LaTeX file that then is compiled to a PDF.
[10:35] Um um it is very important that the details of the strategy and results are translated into um uh general enough intuition that even a non-expert in the subdomain a a a an econ PhD who isn't in that field could still understand.
[11:12] Okay.
[11:13] Uh Great. So, now it's made the skill.
[11:17] Um it constructed a description just like we talked about.
[11:20] Here's the name, the description produce a one-page PDF summary of an academic economics paper for department visits and seminar prep.
[11:27] Take blah blah blah blah blah.
[11:27] Use when, remember how we talked about sometimes it will just figure out and see this.
[11:33] Use this when the user says summarize this paper or prep me for this or do this.
[11:37] Or hands over an econ paper.
[11:40] So, you can see this description is quite important because this is what's going to get embedded in the LLM's prompt and it's going to trigger this what would potentially trigger.
[11:49] That's why you might not want too many skills cuz lots of things might get triggered in in places that you don't want.
[11:54] Um
[11:57] So, now it's testing it.
[11:57] It's saying does this work?
[11:58] It compiles cleanly.
[11:58] It does great.
[12:00] I put it here.
[12:03] Um
[12:05] It has some style nudges here.
[12:08] Um it already sort of shocking compressed for credit household finance fintech and shift your papers your areas.
[12:14] It's a little I don't know why it knows so much about my research agenda.
[12:19] Um and expand intuition for papers outside them.
[12:23] I can strip that out if you want.
[12:25] So, why don't we for the sake of this, let's first look at what it looks like and then we can try running it.
[12:30] Actually, first what we'll do is we'll try running it while this is um while this is working.
[12:34] So, what I'm going to do is I'm going to pull up a paper.
[12:37] Why don't we pull up a Marcus paper?
[12:40] Should we do that?
[12:41] Do we have an easy access?
[12:43] We'll pull up a assuming we have one where we can find an easy an easy access.
[12:50] a tough one.
[12:51] A tough one?
[12:56] Do you have a preferred working paper you want to do it with?
[13:00] Do you have one where the
[13:01] Let's do optimal unconventional monetary policy.
[13:05] Okay.
[13:07] Perfect.
[13:07] So, let's see if it will do Okay, great.
[13:09] So, we're going to say Um so, actually what's interesting is um
[13:17] So, we're going to exit for a second um
[13:19] because it doesn't actually know that it's there because it has to get reloaded.
[13:24] So, we're going to load it again.
[13:25] And now it should say paper summary.
[13:27] So, you can it here when you do forward slash produce a one-page summary.
[13:31] And then I'm going to give it the optimal policy unconventional policy.
[13:36] And now we'll let this run.
[13:36] And while this is going, at the same time what I'd like to do is just show you what the skill string is.
[13:45] So it's working on the left and on the right I'm going to show you what the skill looks like.
[13:51] So remember it's going to have skills and then there's paper summary and then the thing itself is called skill.md.
[13:57] And so in this um there's the description that we talked about.
[14:03] This is what goes in.
[14:03] And then below this everything below this triple line, this when you execute this skill, it will just copy that whole thing into the prompt.
[14:15] Like it's nothing more complicated than that, which is sort of interesting.
[14:19] It's just an it's just a a description
[14:21] of how to do a task.
[14:23] So it's here's what you're going to do.
[14:25] You're going to get an one argument this or this.
[14:27] If you didn't do this, ask once with ask user question.
[14:33] Acquire it, so that means it's going to download it, verify that it's a PDF.
[14:34] If it's an HTML or something else, so it has some error checking, read it, use a read tool.
[14:41] As with all economists, it says you know read the beginning first and then read the results.
[14:49] I've been told by theorists that this is less common that maybe you jump straight to the model first.
[14:52] So maybe this is not what you I would start jump to the model and then.
[14:57] Yeah, exactly.
[14:59] So there's differences here.
[15:01] So you one could edit this.
[15:02] Compose a summary, here's what you should do.
[15:03] Um I'm not sure that I agree with something.
[15:07] Use variation in Bartik exposures as shock to local labor demand is not great.
[15:10] I don't love that.
[15:14] Um Anyway, so this is sort of the version of what it does.
[15:16] If it's theoretical, replace empirical strategy with model {slash} mechanism.
[15:19] That's nice.
[15:22] If it's structural, describe what it's identifying off of, write the LaTeX file, compile, and and so forth.
[15:30] And then it has some style notes at the end, which you could adjust.
[15:35] So, you know, pretty simple in some ways.
[15:36] Um you could tweak this accordingly.
[15:39] Um you could uh tweak it either within directly in the in within it or do something else.
[15:45] And so now it's basically running on the left, and what's nice is um we can then um once this is done, it's compiled.
[15:54] Uh theory paper with five propositions, so it ran a bit long, but stays within the skills hard ceiling.
[15:59] So, let's take a look at what you um what it is.
[16:01] I'm going to open it up.
[16:03] And we'll have to switch over.
[16:05] Um so let me do that.
[16:13] Okay.
[16:18] So, here it is.
[16:18] I'm going to stop sharing, and then I will share
[16:22] this PDF.
[16:23] And you can tell me what you think, Marcus.
[16:26] If it you give it a grade.
[16:29] The TLDR, the too long didn't read, in a continuous-time macrofinance model with sticky prices and heterogeneous balance sheets, conventional interest rate policy alone can close the output gap, but cannot deliver an efficient distribution of consumption and risk across households and intermediaries away from the steady state.
[16:45] Balance sheet plays a preparatory role pre-positioning who bears duration risk so that subsequent interest rate moves redistribute wealth efficiently.
[16:54] Cool.
[16:55] Is that an accurate summary?
[16:57] That's a good summary. Yes.
[16:59] Okay.
[17:01] Um so it's interesting, so this is a theoretical paper, so then it's just going to talk about the model mechanism.
[17:07] I mean, this is pretty this is a lot of this is a lot of text.
[17:11] I mean, it's a but it's, you know, probably shorter than your paper.
[17:15] Um two market failures we have sticky prices and externalities.
[17:20] Mhm.
[17:23] And I guess the pecuniary so inefficient and risk distribution.
[17:27] This implies inefficient So it's interesting in that I told it to do one page, so it is really trying, you know, it's it's doing arrows and everything.
[17:34] It's like when you're taking notes on an exam, right?
[17:36] Or like you're trying to answer and then really shorten stuff up.
[17:38] Um Plain English logic, how much an interest rate cut redistributes depends on the direct how duration risk was already parked and balancing policies what parks it.
[17:51] Load-bearing assumptions are an intermediate bond market segmentation and the central bank's ability to set rates on excess and required reserves independently, plus log utility and continuous time which makes aggregation tractable.
[18:02] Would you say that these are the the right load-bearing assumptions?
[18:08] Yes.
[18:10] These are assumptions, so I mean there are seven particular points assumptions which play but it it captures the main
[18:19] Captures the gist of it.
[18:21] Yeah.
[18:21] But the theory is the very I'm very picky to get exactly the mechanism
[18:24] Right, you know.
[18:25] Right, exactly.
[18:28] So do you feel like so it says it operates in two two channels.
[18:32] There's a direct channel which is a wealth transfer and then indirect which cuz the bond prices go up and then indirect which is nominal wealth goes up under sticky pri- under nominal wealth going up under sticky prices raises all real asset prices which benefits whoever is levered in real capital to typically intermediaries.
[18:50] That's cuz it doesn't talk about I don't think we What's funny is it says this and then it's I don't think it ever defines what this is.
[18:58] So that's a sort of a flaw in this.
[19:01] It's kind of like a bad a bad theory paper.
[19:04] Um plain English though it's kind of conceptually the right idea.
[19:09] So yeah, so I mean this is sort of a fun one in that it's like doing a summary.
[19:14] I have to say this would be probably skipping through this would be faster or easier in some ways than some of it.
[19:20] And then I think one of the things here is you know, thinking about
[19:25] what are the challenges and some ideas,
[19:27] you know, questions that you could follow up with or talk about.
[19:29] Okay.
[19:31] Um so that's, you know, this is a very straightforward example.
[19:35] It's nice about it is that you know, you could do this for any given paper if you didn't have enough time to kind of read Say a good example of this this is like you could really scale it up.
[19:45] Is now, given the skill, we could add another skill, Marcus, where we say, all right, we got all the NBR working paper, we got the mailing list.
[19:54] Mhm.
[19:56] Rather than read the abstracts, what you could do is you could write a skill that you're going to say, I I've copy pasted this week's NBR email list, make me kind of the key give me a list of all the key results from the papers this week.
[20:13] So that would be kind of a fun way to do it.
[20:15] It would go through every PDF and it would do that as well.
[20:19] So we're going to leave that as an exercise to the to the viewers.
[20:22] Thanks. Okay.
[20:22] You can tag us if you do this exercise, but I think it would be very
[20:25] straightforward to do that. It could be
[20:27] very fun.
[20:28] Um
[20:30] So, let me now kind of talk about um
[20:34] that's kind of making your own skill and
[20:35] it's kind of
[20:36] I don't want to say trivial cuz it's
[20:38] it's not totally obvious, but it is um
[20:42] in some ways
[20:44] kind of simple because the whole point
[20:47] is that you have
[20:49] it's a pretty straightforward There's
[20:50] not a lot of thinking involved in that,
[20:52] right? There was some thinking, but it's
[20:53] not
[20:54] complex.
[20:55] So,
[20:57] you know, there's a lot of skills that
[21:00] So one thing to keep in mind is that
[21:01] Claude and Codex as well, all these
[21:03] other coding harnesses, one of the
[21:05] benefits had This is an interesting,
[21:07] like, um,
[21:08] competitive competition policy question,
[21:11] is that
[21:12] this is sort of stuff that Laura Welp
[21:13] can works on, for example, is that
[21:14] they're getting a lot of data from
[21:16] people using their product, right? When
[21:18] we use Cloud Code, they see how people
[21:21] use it, and they are working on building
[21:23] things to make the tool work better.
[21:26] And so, there's a huge amount of, um,
[21:29] skills built in to the Cloud Code
[21:33] itself, tools and skills. They're
[21:36] continuing to kind of roll things out.
[21:38] So,
[21:40] it's just sort of worth knowing that
[21:41] there's a lot of stuff that's built in
[21:43] to, in order to make things work better.
[21:45] Um,
[21:47] there are also a number, there's an
[21:50] ecosystem of, basically, skill packs
[21:52] that people have made. And that was the
[21:53] examples that we looked, the example
[21:55] that we looked at when we talked about a
[21:56] referee report revision. There was a
[21:58] revision skill that we talked about. Um,
[22:02] there are a number of other skills that
[22:04] you can use. And so, the the kind of the
[22:05] most famous ones are the
[22:06] >> for skills or something?
[22:08] >> I'm sorry?
[22:08] >> It's like an app store.
[22:10] >> Exactly. There's just a
[22:12] There's just a number, people,
[22:16] you know, in the open-source community,
[22:17] there's just a natural tendency to be
[22:20] like, here's a bunch of skills that I
[22:21] wrote, and people put them up. They're
[22:22] all text files. Um,
[22:25] the one that kind of gained a lot of
[22:27] popularity early on was this superpowers
[22:30] set of skills. Um,
[22:33] I want to show that one very quickly,
[22:35] just because I think it's it really
[22:37] highlights the difference of what we
[22:39] just did, which is just kind of a
[22:40] repeated, um, process versus like a
[22:44] really thinking about a a problem. Um,
[22:47] but there's lots of things. I mean, one
[22:48] of the things you can do, and this is
[22:49] something we're doing at, um,
[22:51] at the LSOM, is that you can build an
[22:54] entire repository. So, for you, example,
[22:56] Marcus, you could build a set of skills
[22:59] that you think are important for your
[23:00] workflow. And what you could do is maybe
[23:02] you have RAs or co-authors who work with
[23:05] you and you could have a GitHub
[23:06] repository where you keep all of them
[23:08] and people could share those with you in
[23:10] terms of this is the way that you want
[23:12] to do things. And so it's the
[23:14] cloud makes it very easy to kind of
[23:16] implement those types of
[23:18] those packs. And they work in a number
[23:20] of different ways. And so I'm going to
[23:21] show you one example. This is much more
[23:23] like
[23:24] programming adjacent, but I'm going to
[23:26] show you one example of kind of how to
[23:28] use that. And then we're going to and
[23:29] then we're going to wrap up.
[23:31] Um
[23:32] So let me let me show you here
[23:34] how to do the example. So this is
[23:37] this is one of the superpowers that we
[23:39] talked about. So this is called the this
[23:41] is the superpowers um
[23:43] skill set.
[23:45] It's really for software development but
[23:47] it's
[23:49] This is so this is on GitHub. Um
[23:52] we'll post the link to it but if you
[23:53] search GitHub superpowers, this will
[23:55] show up. It's a basically a skills
[23:57] framework for software development. Um
[24:00] let me make it a little bigger so it's
[24:01] easier to read. And
[24:04] you know, rather than go through all of
[24:05] it, what I just want to kind of
[24:06] highlight is in the skills, there's a
[24:09] number of skills that they do and I just
[24:11] want to show you kind of the detail of
[24:13] what this means. So when I started this,
[24:14] I said one way to think about skills is
[24:16] that they're actually
[24:17] telling your agent LLM how to think.
[24:20] Um
[24:21] which we sort of did in that example but
[24:23] not really. And so this one is called
[24:26] brainstorming. So this is a brain.
[24:28] Anytime you do any creative work,
[24:30] creating features, building components,
[24:31] adding functionality, modifying
[24:33] behavior, it explores the user's intent,
[24:35] requirements, and design before
[24:36] implementation.
[24:38] So this is kind of the version of
[24:40] you know, I say like I want to do X
[24:42] and it says, "Okay, well rather than
[24:44] just like jump right into it, you should
[24:46] really think a little bit about how to
[24:47] turn that idea into an actual executable
[24:49] task."
[24:51] So what does it do? So
[24:53] I just I we're not going to go through
[24:55] everything here
[24:57] but
[24:58] what it's trying to do is it's it says
[25:01] everything has to go through this.
[25:04] It's trying to basically get rid of the
[25:06] idea of anything is somethings are too
[25:08] simple they need a design. It says, "No,
[25:09] no matter what you should always do
[25:11] this." Because often simple projects
[25:14] create these assumptions that then
[25:15] create a ton of wasted work, for
[25:17] example. This is very much a software
[25:19] engineering perspective, but probably
[25:21] true in in this.
[25:23] It makes a whole checklist. Here's all
[25:25] the things that you need to do.
[25:27] Is a flow of how things should work.
[25:29] This is like a graph in terms of how we
[25:31] should think about things. So, explore
[25:32] the project, think about visual
[25:34] questions ahead, should you offer a
[25:36] visual companion, ask clarifying
[25:38] questions, propose approaches, present
[25:40] design So,
[25:41] I'm not going to go through everything.
[25:42] It goes on and on.
[25:43] >> companion? Sorry.
[25:45] >> Um So, I actually don't use this here,
[25:48] but well, here if we skip down to what
[25:49] this is,
[25:51] the visual companion is a browser-based
[25:53] companion for showing mock-ups, gra-
[25:55] diagrams, which are like graphics, um
[25:58] graphs, visual options during
[26:00] brainstorming, available as a tool.
[26:02] Basically, it will show you what things
[26:04] look like. It'll do mock-ups of what a
[26:06] thing would look like. So, imagine
[26:07] you're building a website. In the
[26:09] brainstorming mode, it will pop up a
[26:11] website so you can see what the example
[26:13] of what it has in mind would be.
[26:15] So, things like that.
[26:17] Um
[26:18] This is actually relatively I don't My
[26:20] version is not up to date. I think he
[26:22] added this in, the person who developed
[26:24] this. Mine doesn't do this. So, this is
[26:26] a huge amount of stuff, right? It's
[26:27] really saying like, "Here's all the
[26:29] things you should be thinking about, how
[26:31] you should work with this. After you've
[26:33] done the design, you've thought about
[26:34] the process, you write the specification
[26:36] here into these documents,
[26:39] and then you
[26:40] um use these skills in terms of thinking
[26:42] about writing clearly and concisely, and
[26:45] then you commit it, and then you review
[26:47] it.
[26:48] >> Mhm.
[26:49] >> And so, it's really kind of like you can
[26:50] see that this is a little this feels
[26:52] like a lot of detail. And certainly it's
[26:54] more than what we talked about. A lot of
[26:57] additional detail. And
[27:01] And then it actually even has
[27:03] someone else review it. So what it does
[27:05] is it says
[27:09] you should basically
[27:12] implement a review
[27:15] where it's going to say, "Here's what
[27:16] I'm going to do. Review this and make
[27:18] sure that it's clear." So it even has
[27:20] somebody review it.
[27:21] >> reviewing it.
[27:23] >> Well, what I mean is another agent
[27:24] inside of it. So what it does is it
[27:26] writes the plan.
[27:28] And then it says, "Hey, you should
[27:30] develop you should send off another
[27:32] person who you're going to be this kind
[27:34] of person.
[27:36] You're going to review this
[27:37] specification this document and here's
[27:40] what you should look for." And really
[27:41] what it's trying to look for is things
[27:42] are complete and consistent and clear.
[27:47] So
[27:48] you know, this is just this is just
[27:50] within brainstorming. So just to give
[27:51] you a sense, there's many of these here.
[27:54] Um dispatching parallel executing a plan
[27:57] where executing plan here is it loads
[27:59] the plan like what we just did before
[28:01] and here's what you should do.
[28:03] And so some of these are very simple.
[28:05] Like this one is relatively simple.
[28:08] Um but some are much more complicated.
[28:12] So I just want you have a sense of like
[28:14] these are the types of things where
[28:16] you're basically giving it a way to
[28:17] think about this. The last one that I'll
[28:19] say that can be very a a useful thing
[28:21] that's not on here, but I had a friend
[28:23] tell me about this as a potential um
[28:25] tool is
[28:27] uh one thing that you could do is
[28:29] imagine you have an idea. Right? You
[28:31] have an idea for a project. But really
[28:33] what you need, you know, you're working
[28:35] on this project solo. But what you
[28:37] really would like is you'd like a
[28:39] version of someone who's who's, you
[28:41] know, like your advisor
[28:42] saying
[28:44] here's where like let me push you on all
[28:46] these things. You could develop a skill
[28:48] that basically says you should be asking
[28:51] me questions about this research thing.
[28:52] Push on anything that seems like a weak
[28:54] part of it.
[28:55] >> Mhm.
[28:55] >> Um and anything where it is weak, let's
[28:57] make a note of things that need to be
[28:59] flushed out more and like then develop a
[29:01] plan of what we need to do next. And it
[29:03] can do it. So, the one that I've seen
[29:05] isn't about this, but it's about I want
[29:06] to develop a project and it's going to
[29:08] do X. So, there's really a lot of
[29:09] powerful things you can do with these
[29:11] skills um that are really about
[29:13] structuring it and and pushing in a
[29:15] particular way.
[29:16] Um
[29:17] So, yeah. So, I think I've I'm cracked
[29:20] only the surface in terms of thinking
[29:21] about this. I don't use it as nearly as
[29:23] much as I would like. I think there are
[29:24] people who use it quite a bit and are
[29:26] are quite passionate about it. Let me
[29:27] kind of end by just a quick a brief
[29:30] warning about this.
[29:31] One of them is this thing that we
[29:32] already talked about. Don't go crazy
[29:35] with these things. Right? Skills fill up
[29:37] the context window and they're kind of
[29:38] confusing because some might get
[29:40] triggered in other places. So, being
[29:42] precise in what you want is important.
[29:45] And then the other is, you know, I
[29:46] advocated that there's these superpowers
[29:48] and other things is that you know,
[29:50] skills from others could potentially be
[29:51] malicious. Right? So, if you think about
[29:53] what's going on, you're letting other
[29:55] people decide how things should be
[29:57] loaded into your prompt. Now, these
[29:59] agent these LLMs and other things are
[30:02] have a lot of things hardcoded in them
[30:04] to prevent them from doing something
[30:05] dumb.
[30:07] But, they can still do incredibly dumb
[30:08] things. Like, imagine you loaded in a
[30:10] skill that says
[30:11] you know, you should remove all
[30:13] important files in this folder anytime
[30:15] somebody asks you to do something. That
[30:17] would be a pretty horrible skill. Now,
[30:20] it's all in plain text, so it's unlikely
[30:22] something would be like this, but this
[30:23] is a thing that people worry about. So,
[30:26] hopefully that's useful. I think there
[30:28] are I'd be really interested to hear
[30:29] kind of what people do with this, you
[30:31] know, how they how they kind of uh make
[30:33] progress and um
[30:36] yeah, that's what next time we'll talk
[30:37] about containers and thinking about uh
[30:40] kind of more generally how to think
[30:42] about allowing LLM's to have much more
[30:44] permissions.
[30:45] >> Okay.
[30:47] Great. Thanks a lot, Paul. We're going
[30:49] on to the next video then soon to
[30:51] permissions, containers, and sandboxes,
[30:54] and open claw, and things like that.