Skills are, in my view, one of the most important and probably
one of the most underused features in the.
Cloud ecosystem right now. And even arguably beyond the
cloud ecosystem, if you're using cloud for anything serious, you
probably hit. This problem.
You've got it working exactly how you want it for a specific
task that has a perfect output, and then the next time you have
a conversation it's just begotten everything.
You could copy and paste instructions into the chat every
time, and many people do this, but that doesn't scale.
GPTS or clawed projects help, but they're not the same as it
understanding a process for a specific task, and they fill up
the context window far too quickly.
Because you preload them. Full of so much information.
To it has the information it needs to help you do a task.
And so you're constantly running out of space in a conversation
and having to start a new thread.
The solution is skills. A skill is a set of instructions
you write once give to claw. Encode your process and your
preferences, and today we're going to go deep on them.
We're going to go into the actual principles of context
engineering and why skills are so important.
The exact anatomy of a skill file with real examples that you
can use today and how you can make them and how you can chain
different ones together and where to.
Find skills and install them. How they fit alongside MCPS.
Or plug insurance. And we shouldn't.
Even bother using them at all, this is in the loop.
With Jack Horton. Hope you enjoyed the show.
Before we get into what skills are, I think it's probably worth
understanding the problem they were built to solve and kind of
what they consist of. What is a skill?
Because once you understand that, I think everything will
start to really fall into. Place so throughout. 2025 AI
coding agents were getting dramatically better and better.
Core code could suddenly, you know, build really complex
systems. They could.
Read an entire file system. They could.
Interact with Git. They can run tests, they can
deploy things, and the capability was obviously there
to do really cool stuff. But what most people found is
they hit a wall, and that wall really was the context window.
We've talked about context engineering before in July 2025,
and it's the same for even those that are not using core code.
The amount of times you just run out of space and this happens
with GPTS. And core projects.
And what's actually happening here is that every time you want
Core to obviously know something.
Whether? It was your, I don't know,
teams, coding standards, how an API works, the context of the
market or the business you're working in.
You basically be pasting lots of information to the chat, which
essentially crams. Everything into the.
LLM System prompt which is this big long prompt.
It gets sent to an LLM that defines, you know, its.
Purpose. How it should behave?
What it should? Do and as agents and LLMS get
more powerful, the list of things that.
Is included. In that system.
Prompt is always growing, so there's more instructions,
there's more tools so the integrations it can use.
So that system prompt is just ballooning.
And the problem with that is that the context windows are
finite. The more you step in there, the
worse the agent starts to perform.
It gets slower and more expensive, less reliable, and
there's a real tension between giving an agent you know as much
information as possible and making it able to execute
consistently well. And this insight is what led to
skills. Agents don't need all of that
knowledge and information all of the time.
What they need is the right information, the right ability
to run a process, or awareness of a process at the perfect
moment. And so in in about late October
2025, Anthropic published a blog called Equipping Agents for the
Real World. With agent skills.
And they framed. It kind of like this they.
Said Claude is really powerful, but real work requires
procedural information and just organizational contacts.
And as agents become more and more capable, we need more
composable, scalable and portable ways to equip them with
that domain specific expertise. And that's what led to agent
skills, which essentially are an organized set of folders.
Full of instructions and resources that help agents.
To basically discover and load the right thing at the right
time and I think the key phrase. Here is dynamically.
So these skills. Aren't always there for.
The agent, they're not sitting in the context window taking up
space. They only get loaded when
they're relevant and stay out of the way when they're not.
And that's A, and that's a fundamental.
Design. Principle of any modern day
agent. Really you know and topic is a
specific. Name for it.
That's been adopted. Everywhere.
Which is called. Progressive disclosure so you
progressively. Disclose more information to the
agent needs. Only.
Actually when it needs it. So this progressive disclosure
happens. In three layers.
Layer one when Claude starts a. Session it basically preloads.
Just the name. And the description of the
skills. So not the full set of
instructions, just a one line summary.
You know, maybe 100 tokens per skill.
So again, a few words. This makes it possible for the
agent to know, I guess, what is available to it.
We just talked about this before, the tools that were
available to this agent and therefore it's cheap enough to
always have those small. Descriptions loaded.
Then you've got layer 2 when when essentially Claude
encounters a task and recognises that one of those descriptions
is relevant. It then loads that full skill
file and as a result it will have the complete.
Rules and instructions that you. Create for it, but only does it
for that specific skill, not all of the skills.
So again, you could give it dirty.
Skills or tools? And it will only.
Use one of them so again. Protecting that context window,
and then you've got layer three. If the skill MD file references
other files in the folder of templates or reference docs or
scripts, code will actually be able to navigate to those as
needed. It doesn't read everything
upfront, it follows it for references.
So if a process that it's following says use this extra
doc, it will then go and find that extra dock.
It won't then load every single skill.
Think about it like a set. Of instructions.
Basically layer 1 is like the table of contents, layer 2 is
that you know, relevant chapter I guess and layer. 3 is the
appendix. You don't need the whole thing
every time. So now you understand, you know,
why we have skills, why they're important and what they're kind
of made-up of. I think then let's build a skill
together. And I think the walkthrough.
Of this. Helps you.
Really understand what a skill is beyond just me using.
Kind of abstract words, instructions, because I think
it's really important to. Understand the mechanics.
And the specifics here. So if we build 1 together,
right, you have to picture this. So let's say you write a team
update every single Friday, and every time you ask Claude for
help with this, you end up giving it basically the same set
of prompts every single time. You know, keep it under 300
words. Lead with wins.
Plain language, no weird AI, slop language.
End with the blockers and every few.
Weeks Cloud does something annoying.
Maybe it allowed a random sign off or use the wrong language
again and you have to then. Correct it.
So here's how you would solve that with skills.
Now before I get into this, it's.
This is a few bits of a process here, and it's also important to
note that on all the cloud interfaces you should have an
option of just either having a skills creator.
Or just telling. Claude, create all of this
process as a skill and review it and collaborate with it.
Collaborate on this skill with me.
So you can actually tell it to turn things you've been working
on into a skill, then review it. But I think for the purposes of
this discussion, it's still important to understand how to
create one because it'll give you an in depth understanding of
what the heck this thing is. So step one would be create a
new. Folder on the computer, call it
weekly update or tell Claude to create a folder and call it
weekly update. Tell it to organise.
It as it. Sees fit or it.
Makes sense. Remember the core Co work
episode we've done I think about 5 weeks back?
If you haven't listened to that, I'd recommend also listening to
that alongside this episode. Anyway, Step 2 would be to go
inside that folder, create a new.
File and it's a text file, you name it skill dot MD.
All caps for skill then dot MD. For the extension.
Step three. You open that file and at the
very top you're going to give. Cloud 2 piece of information,
you name the name of the skill and a one line simple
description of what it does and that's.
It below that you write actual. Instructions for example.
Write a concise weekly team update following our style of
format. Use when the user asks for help
with a weekly update or. Stand up summary or team status
report. Now notice that description.
I've included a few trigger phrases.
Weekly update stand up. Summary team status report.
So this gives Claude multiple ways to recognize when this
skill is needed. So if I then in a conversation
say I am writing this team status report, it would then
pull up and use this. This tool or this this?
Skill Step 4, you would then write the body, which is the
instructions. So you'd call it a heading
weekly team update format. And then when asked to write or
help with a weekly team update, all of these rules and then you
set the rules out. You can also have areas called
structure, you know open with a section called wins of the.
Week. Containing 2.
To four bullet. Points of complete work.
You could have tone so don't use AI jargon and weird corporate
pillar. Keep it in first person.
You say LEMP, keep it under 300 words and then add a section
called gotchas. So never use phrases like
moving. Forward or synergy or circle?
Back don't sign off saying kind regard because this isn't an
e-mail. This is going into a Slack
channel. And that's what a skill file is.
And the gotcha section is something Anthropic specific
calls out as one of the highest signal content in any set of
skills, One of the. Claude.
Code team members actually wrote that in a in a blog post that
the highest value thing you could possibly do is build up a
gotcha section over time so every time Claude makes a
mistake you can add to it. The skill becomes a living
document that essentially accumulates your hard won
knowledge about what goes wrong and how to prevent it.
So every time you're having a conversation with Claude, say I
want you to update the skill dot MD file for XYZ skill with.
These new gotchas and. Again, you're just building up.
Constant information and knowledge on this.
And then finally, obviously you. Save the file.
So that means you've now got a. Folder called weekly.
Update with a file called skill dot MD inside it.
You can then install it. And this depends on how you use
calls. If you're using cloud dot AI, so
the web interface, you zip that folder, not the file, the actual
folder itself. Right click the folder, compress
it into a zip and then go to cloud AI.
And if you go into settings, you can actually.
Go into customize and then skills and then you can upload
the skill using that zip file. If you are using the web
interface, which I recommend no one do, you should be using the
Co work interface or core code. But if you are using that you
need to go and turn on code execution and file creation
skills. Kind of need that to function if
you're using. The core code interface.
It's really easy, you just tell it to do it and it will bash
command it. It'll just set it up for you now
if you are. Writing Organization.
Wide skills you'll probably need to speak to your admin, but you
can even tell it to make this a personal skill or a team wide
skill if you're using clouds COA which is the.
Desktop interface skills can come bundled in plug insurance
or just upload them through the same settings panel.
As Claude dot. AI as I said Claude Co work is
the same agent as Claude code so.
You can basically ask. It to just do it for you.
And they've just released a new feature for most people called
the Skills Creator, which just helps you create a.
Skill. So yeah, once you've done that,
every time you start a new conversation, Claude sees all
the different skills that it's got available to it and it's
descriptions. That's that layer one.
It costs almost nothing in context window and capacity and
then when you say something like here are my.
Notes for this week's. You know, write up our update,
it will then load up that skill and it will work.
Now really quick, really quick note here.
It could probably be quite attractive to start turning
everything into skills when that's just not necessary.
So if it's a one off task, just use prompts.
If it's a repeatable task that you do a.
Lot or you need other. Team members to fulfill.
Then you can make a skill. And when you write.
The skills. There's a trap.
You don't need to. Reinstate what Claude as a
baseline model already knows. Anthropics guidance on this is
really really direct, so don't tell it how to write Python
because it knows. How to write Python?
Don't tell it what good code looks like in general, tell it
what good code looks like in your specific code base.
So again, it's about making it contextual and writing it out
your process that you want. This thing to follow and then
once you've built a skill, test it.
Don't just use it once and go, oh, that was good.
Use the skill. Creator's Evaluation.
Tools run the skill against different prompts.
And then don't. Make it too prescriptive so
there's a difference between. A skill and a.
Template templates. Break the moment.
The situation changes. We talked about this last week
and you'll notice this is all about reliability.
And consistency. If you write something that is
if this, then that. It's.
Going to be. Quite rigid.
And therefore. If you need to be flexible, it's
not going to work in the same way.
So again, Quad and Anthropica are very clear here.
It's about a skill. Not a template.
So yeah, that that's how to make a skill and when not to make a
skill. But I also wanted to talk about
how to make skills extremely powerful.
So if you imagine, that's kind of like getting started.
This is now moving into. Advanced thinking, not because
it's super complex, but because it makes such an extra impact on
how you work. And that's skill chains.
So yeah, the next level is when skills start working together,
and I'm going to give you an example of four skills that feed
into each other to form a complete development process
from a vague idea all the way. Through to tested ship code.
And it came from a developer called Map Poco.
And you might be thinking, oh, but I'm not a developer now.
I'll also provide a couple of extra examples here about.
Non developer or product focused tasks.
So the first skill is called. Grooming.
And I'll read it out in full because I think it's important
to hear just how simple a skill can be.
The entire skill body is 3 sentences.
Interview me. Relentless about every.
Aspect of this. Plan until we.
Reach a shared. Understanding.
Walk down every single branch. Of the decision.
Tree resolve any dependencies between decisions 1 by 1.
And finally, if a question can be answered by exploring the
code base, explore the code base instead, so.
Three sentences and that's the whole thing.
And he said Sessions where I called asked him 30-40 fifty
questions from that tiny skill before it was satisfied that
they understood the problem. And you might be thinking, gosh,
that's a lot of typing. But if you've not got super.
Wispy yet? I recommend you to go and pay
just a few pounds a month. I think they.
Also have a pre tier but it's just an amazing basically voice
tool that you can press a shortcut, it appears and when
you're finished speaking the text appears in any text box.
It makes my life infinitely easier.
But anyway. And then?
Once the grilling. Is done.
It'll invoke a second skill, write a PRD.
So this is a structured multi step skill and apid is a
product. Requirement document says.
What people in product write. Before they build something
so-called. Will then start to ask the user
for a detailed. Description it'll explore.
The repo to verify any. Assertions it will interview.
And once all this is done, this. Document's written.
It will also submit this as a GitHub issue, so actually raises
it in the system of record to track work.
And So what comes out on the other end is a ticket or.
An item of a a task to be done. With a full document, with a
problem statement, a proposed solution, detailed stories.
In the right format, implementation decisions.
And then it will. Trigger 1/3 skill called the PRD
to issues. That takes the document and
breaks it. Into a series of individual.
Tasks each task. Is essentially A deliverable
piece of work that the team can work on.
For example, it will start with. What is most important to start
on? Usually the things with the
highest risk to a project. The skill will also establish.
Blocking relationships between. Tasks.
So task 3 might depend on task one, but task 2 might be
independent and should be therefore picked up in parallel.
So this is really useful if you're running many different
agents at the same time. For example, this is what a
product manager and a developer has to be.
Finally, when it's time to implement, there's a Test Driven
Development skill. So basically is a process that
enforces and confirms with the developer what interface.
Changes are going to be needed. Agreed.
Therefore, which behaviors we have to test and then enter a
loop and you can't? Have that thing finished until
it achieves those sets of behaviours that you were looking
to. Actually achieve so.
That's a very. Product centric example that the
take away here for non developers as well is that.
This principle. Of chaining works regardless of
domain, so and even that process.
We went through. You could build a research
brief. Skill that feeds into a draft.
Article skill that feeds into a format for newsletter skill.
The exact same architecture, discovery, planning, execution,
each skill picking up where the last one left on.
And this mechanism is domain agnostic.
The instructions inside is what makes.
It specific to your work. Now you might be thinking, gosh,
it's really exciting, but maybe a lot to get.
Started on here. Well, there are places for you
to go find other skills, bring them in and get inspiration.
I will have one warning. Which is obviously when you're
downloading things from the Internet that are just very
public and inside a community. It does present risk.
So if you bring that straight into your.
Your environment that you're doing coding from or whatever it
might. Be.
You need to make sure that you're going and getting trusted
verified sources. So just just a.
A preface that. Super popular ones, probably
more say, but going on random websites and finding skills and
downloading them. Will always present some risk.
So anyway, Anthropic has got an entire skill set of a skill
library, should I say, on the GitHub reposogithub.com
Anthropic. Skills.
You know there's skills by creating word docs, excel
spreadsheets. PowerPoint presentations.
PDS. Beyond Anthropic, the community
is massive now. There are curated collections on
GitHub with 10s of thousands of stars.
There are directories listing. Thousands of community skills
and there's even growing ecosystems of plug in.
Particularly in core Co work and for those that don't understand
the difference. Between skills, MCPS and plug
insurance. There's often a lot of confusion
here. Think of it in three layers.
Skills are the knowledge layer, so they tell Claude how to do a
thing. So a.
Process or a preference. A skill doesn't connect Claude
to anything in the external world.
Just makes it smarter about a. Particular task MCPS.
To model context protocol are the connection layer.
They let Claude reach out into your.
Slack your GitHub repo. Your CRM your.
Calendar. And plug insurance are basically
the. Packaging layer.
A plug in bundles skills, MCPS, other resources together that
you can just then install in a single gap.
So instead of separately configuring a Slack MCP, writing
a skill for how your team uses Slack, and then setting all that
up manually, you can just. Create a plug in that does all
of that together. Skills of the brain, MCPS of the
hands and. Plug insurance the toolbox, and
the best thing here is that skills aren't just an.
Anthropic thing. It was published.
As an open standard in December 2020.
Five and. Since then it's been adopted by
loads of tools like Open AI codecs, GitHub Copilot VS Co
Cursor, Gemini. They're all supporting the same
format. It's one of the fundamental ways
that would build a. Lot of new.
Functionality now. On our product.
Aligning ourselves with that ecosystem.
So yeah, let's conclude for today's episode because here's
the bigger picture. We're in this massive
transition. From using AI.
As a conversation. To using.
It as a library of reliable. Repeated.
Capabilities and every time you figure out how to get one of
these things, these systems, these large language models to
do something well, you can capture that knowledge.
So it compounds over time, and that's what skills are
compounding information. That you and your team can
leverage over time. Skills turn.
One person's expertise into everyone's.
Capability your best. Engineers review process
becomes. A skill the whole team can run.
Your best writer can be the foundation to how every person
in your company writes content. So if there's one thing to take
from this episode, it's this The next time you find yourself
giving called the same instructions the third time in a
row, just stop and write skill. We'll look to link everything
into the show notes. You know, documentation skills
repos basically as much as. Possible for you to.
Get started on. Skills anyway.
That's it for me. I hope you enjoyed the episodes.
And I'll see you next week.