00:00Claude skills are arguably a bigger deal than MCPs

00:03So, in this video, I'm going to break down why and then show you five Claude skills that are already changing how I build

00:12So, if you're already a subscriber, strap in because it's going to be a good one

00:16And if you're new, my name is Sean

00:19I used to be in the startup world

00:21I took a break to help build and scale an 8 figureure marketing company

00:26And now I'm back learning and implementing in the world of AI

00:28And I like to bring real world tangible tactical grounded use cases for these tools

00:37Now, in this video, I'm going to go through why skills and not MCPs or agents for certain tasks

00:43Then I'm going to break down the five skills that I think are awesome, how to find them, how to use them

00:49So, if you like AI coding and vibe coding and you want to squeeze every last drop out of tools that actually move the needle, this video is for you

00:58So, first things first, before I get into those five tools, why skills over MCPs or agents? Well, first off, skills are very token efficient because they're engineered to progressively disclose context as it's needed

01:11It's also automatically invoked

01:15So you have access to the skill

01:18Claude is very good at understanding based on examples when to use that specific skill and pull it into its context

01:27It's very good for procedural work

01:30Meaning if you have a stepbystep system that you tend to go through for repeatable tasks, that is when a skill is going to be valuable

01:37So it is the consistent application of a standard

01:44So whereas MCP servers give an AI access to external resources and tools, skills are more about teaching the system how to use all of the tools at its disposal in a very systematized way

02:00So a sub agent operates in its own subcontext window separate from that main thread that you are chatting in when you see the sub aent called

02:10Whereas skills are going to operate directly inside of the main context only calling resources or using things as it's actually needed

02:18So think anytime you have a systematized repeatable process that should be done in a specific way or that the system should have specific knowledge that it knows to apply in a specific way every single time in the same order

02:32That's where skills are going to be very valuable

02:34So that being said, let's get into the five that I already love using

02:38So, first things first, you have to make sure you have Claude plugins enabled

02:42And the way that you do this is you go into your settings inside of Claude desktop, for example, and you go into capabilities

02:53When you scroll down, there's going to be this option, which for you, there will be a turn on switch right here under skills

02:59Once you enable this to allow skills, you'll have access to plugins inside of your Claude Code instance

03:08So, what you're going to want to do is go back into your Cloud Code instance

03:12And now, if you type in /plugin, you're going to have access to this plugins feature, and you want to go down first to add a marketplace

03:19So, for every single like repository of these things that you want to add, you need to first add the marketplace

03:24and it's giving you some examples of what those look like

03:29So, in this case, we want to add the specific repository for the anthropic skills because this is where some of the skills that I'm going to show you are

03:41So, what we do is we pop back into VS Code and just paste that in

03:42And now, in this case, it has different collections of skills

03:47And so, I'm going to go down to the example skills and I'm going to say install

03:51And now I have access after I restart my claude code to these specific skills

03:56So we're going to follow that process and I'll have instructions in the description below for each of these marketplaces that we are going to look at

04:03So the first on our list is going to actually be the skill creator

04:07So one of the things that's really cool is that they have a skill for creating new skills so that you can create it with the proper level of like abstracting away principles versus being concrete about what you want

04:20And so the best way to get started with this is to just go into claw desktop or inside of cloud code, go into your capabilities

04:28And in this case, you can just toggle on the skill for skill creator

04:30Once you've done that, you can ask it what you want a skill built around

04:35So in this case, I'd like to create a skill so that my UI guidelines get applied to any component that gets built

04:42Can you help me with that? And so the thing that's nice about this is it's going to go through and it's going to ask you specific questions that it would need to have answered in order to actually run this skill properly because again remember these things get automatically invoked by the system

04:59We're not calling them through like a a slash command for example

05:02And so in this case it's asking us what kind of component it are we actually building

05:07So is it like a react component view like what is it? What are the specific UI guidelines you would want actually enforced? Do we have this documented somewhere? Are there specific other assets that need to be included? And then can we give some examples of when it would be invoked so that it's using it at the right time? And so I went through and gave some basic answers for this one about when it's going to be called, what it needs to do, all of that type of stuff

05:32And the thing that's nice about this is it is going to continue asking us questions until it has the answer that it needs

05:39So in this case, it wants me to share the path that's going to be used because I told it that the design documentation is always going to be inside of the project

05:49Now once this is done, you are going to have a zip file

05:54And so what you can do is you can go and download this zip file to your computer, unzip it, and then drag the unzipped folder into a skills folder inside of your.claw directory

06:06So we haveclaude/skills

06:11And then in this case, we could just upload that UI guidelines folder that we just unzipped

06:15So, let's say we're inside of a project now and we want to make it so that when the user actually selects this, which isn't even working in the first place, that it creates a searchable dropdown that actually conforms to our brand guidelines

06:27So now, if I was to hop back into my project here and say when a user hits that command K button on their keyboard, it shall open a quick command pallet that allows them to search prompts

06:37So now what is going to happen is we can see that it is automatically selecting the skill from the skill guidelines which means that everything in here is going to be used as a codified set of rules that the system will follow

06:55Now this leads us to one of our next skills

07:00So if we hop back into GitHub there's this repository called superpowers from a creator called Ora

07:05And these are all different clawed code specific skills which I have installed via the plugins that I went through earlier in the video

07:17And so we'll notice that one of the superpowers they have is called brainstorming

07:21Which means anytime we go to create something, whether that's writing code or creating an implementation plan, it's going to take a rough idea and it is going to help you flesh out that idea through a procedural kind of Socratic line of reasoning

07:36So when we say okay, we can see that the brainstorming skill is now loading and it is most likely going to come back to me with specific questions or thoughts to help us refine this plan

07:47And it goes through a few phases

07:52understanding, exploration, design, presentation, design documentation, and then if needed, it will set up a separate work tree or a plan handoff depending on whether or not we are actually implementing this thing in one fell swoop

08:07And so what it's asking us now is, well, what action should that command pallet actually support? And this is something I was thinking of

08:14In this case, I just want it to be able to search and open prompts, but down the line I am going to want it to be able to do other stuff

08:20So, right now, we're just going to say search and open prompts

08:22And then maybe even search within the version history for the prompts

08:26And then I can say submit answers

08:28And boom

08:28It now knows what I'm trying to do

08:31And it's going to go off and it's going to brainstorm around that specific set of constraints

08:37And it's going to recursively ask me questions until it has a really dialedin plan

08:41So this one is a gamecher if you are a vibe coder first meaning not a software engineer by trade especially this is going to help you get a lot more disciplined in how you build things

08:51And so out the other side of this brainstorming session, we get a pretty comprehensive system design or plan for this specific feature with the requirements functional and non-functional, the architecture decisions, what components we're going to have and their hierarchy, how data flows between them, how the state is managed, the actual file structure, the dependencies, everything is here for us

09:19at which point we can just continue in this case to use this skill to build this thing out

09:24Or you could have a tool like spec kit take over from here and go through and actually build out everything that you need

09:29So now this one's a bonus skill where another superpower that they have in here or a skill is using git work trees properly

09:38And so part of this whole concept is that we can start chaining different skills together in order to get better and better and better and more automated in our processes

09:48So this is great because git work trees are going to help us work independently from our main tree, do all of those changes that we need and not have to worry about messing up something that we had going on in our main branch that we're working on

10:03So if we back up for a second, which two skills have we used so far? Number one, we use the skill creator to actually generate a skill that ensures we're following our app's brand guidelines or UI guidelines

10:17And then two, we use this brainstorming skill to get a lot of questions ironed out about our app's feature and how specifically we wanted to implement that quick command pallet for searching through prompts in our app

10:33Now, the third skill is going to be what do we do once we have completed that? Because a big complaint that you hear, especially from traditional developers about vibe coders in particular, is that they're inevitably going to run into a situation where the app's in production and they run into a bug and they don't know how to fix the bug because they don't know where it was introduced or what commits might have even been involved in creating that bug in the first place

10:56That's the reason I love this change log generator skill

10:58So what this thing does is anytime a feature is committed to the system, it is going to go through and it's going to create a userfriendly change log so that we can go back and we can look at what commits are actually involved in this feature and what changes specifically did we make

11:18Now in this case it is making us a customerf facing change log meaning something we could publish on our blog or in our documentation and the customer can actually see how this feature works

11:29But we could easily tweak that skill that we had to make a developer oriented change log that's talking about specific commit hashes for the commits that were made, what changes are relevant for that specific commit, the files that were updated, all of that type of stuff we could easily include inside

11:47So these are three skills so far

11:50So if we were to hop back over now into our app and hit command K, boom, we get a prompt search that pops up

11:54And now if I were to click into one of these, it opens me directly into the editor

12:01So everything working as intended

12:03Now you'll notice when we boot this thing up, we get this error down here

12:06So this also created some sort of problem for us

12:09So when this command pallet opens, it doesn't have all of the fields that it is meant to have

12:13And so we could come through and we could copy this error message

12:17We can come into our cloud code in this example and say that we wanted to debug this issue and hit enter

12:25And so this is where we get to our fourth skill, which this is not the best example for it because this is a pretty straightforward issue, but this is a systematic debugging skill

12:33So what this does, anytime it encounters a bug, a test failure, unexpected behavior, whatever it is, it's going to go through a four-phase framework

12:43It's going to investigate the root cause

12:46It's going to go through a pattern analysis, test a hypothesis for the fix, and then move through to implementation

12:51And so it's really trying to make sure it understands the problem before it implements a solution

12:57So we're going to say go and it's going to load that skill in and it's off to the races

13:01Now this skill is particularly helpful when you have harder to kind of deal with bugs that are a little bit more involved

13:08But this will still demonstrate the use case

13:12And there we go

13:12Now this thing is done

13:14I can come through

13:14I can hit command K and we don't have that bug popping up any more

13:17Now the last skill I want to show you is something that they call a simplification cascade

13:21And in order for you to understand why this is important, I want to explain a concept

13:28So in coding, but even in general concepts about the world, you have a gradient of abstract concept to very concrete application of something

13:40And usually depending on how skilled you are at something, you exist somewhere on that gradient

13:45And so let me give you a very concrete example of this

13:46Inside of this project, we have a prompt function

13:51And one of the things that I want to add into this tool that I use for myself is the ability to store agent definitions and potentially even now skills or certain context that I reuse over and over and over again

14:05And as part of this thing that I have for prompts, I have a version history

14:10Meaning, if I go through and I were to make some sort of change to this prompt, it can store the old version versus the new version, and I can compare those different versions to see what I changed

14:21Now, my question to you, if I was to go out there and decide, hey, I'm going to now build an agent library or a context library of concepts that I reuse inside of my prompts, and I wanted to have a version history inside of those

14:38Do I use the same exact version history that I have inside of my prompts or do I need to go out and create a new version history component and logic for every single one? Well, the obvious answer there is that I can probably abstract out the prompt specific stuff from this one and make just one version history component that can work with any types of things that I might throw at it

15:01whether it's my context library, whether it's my prompt library, whether it's agent definitions for different tools that I use agents in

15:09And so what this skill does is it helps us identify when we are building things unnecessarily

15:15And so it gives some examples of patterns to look for

15:21multiple implementations of a very similar concept, having too many special cases everywhere that need to be handled, having super complicated rules with tons of exceptions to it, and then asking the real underlying question, well, what if these are all the same thing? If only I thought about it slightly differently

15:39I don't need multiple different version history managers for each of those

15:43I can just build one

15:45And so this tool helps us avoid those types of situations where we add too much unnecessary complexity and make our app a lot bigger than it has to be because we just didn't have the skill or didn't recognize the patterns that were rolling out inside of our app

16:01And like everything else, we can see this simplification in progress where I know that my query logic is a little bit involved because I can see it dumping what its query is into my terminal and it's a little bit too involved

16:14And so I'm asking can this logic this system that we have for quering the database can it be simplified and so it's going through and it is using this simplification cascade skill in order to build a structured approach to finding like what is that one insight that will eliminate a lot of this complexity that we have going on

16:34And so it's moving through the process that is defined in the skill, finding all the implementations, extracting out the kind of the essence of what it is, finding out what a new pattern could be that's going to actually work, and then ultimately come up with a plan to to solve this thing

16:51And so this is great because we can see it found exactly what I identified because there were moments where I was like, my app should be a lot snappier and quicker than this

16:59And so a few things that it found 15 different independent ownership checks throughout different pieces of my app that are now going to be they have a proposed abstraction right to make that simpler

17:13Some inefficiencies in how the caching and checking the caching is working and a few other potentially like really big improvements that can make this thing a lot faster, snappier, more performant and just better overall

17:28So, I really love this tool also or skill shall I say

17:35So, that's it

17:35Five skills that are pretty cool if you ask me

17:37Now, if you want to see more workflows or tools like this or maybe how we can combine skills with MCP servers, let me know in the comments below and I'll make a video about that

17:49And as always, if you liked the video, make sure to subscribe so that you get more videos like this in your feed

17:56But that is it for this one

17:57I will see you in the next