How Smart People Are Using Claude Code Skills to Automa… — Transcript

Most people are using claw code skills completely wrong.

They build one skill for copy, another for research, and maybe another for social media.

And then wonder why they're still doing most of the work themselves.

But the people getting most out of claw code aren't using skills one at a time, they're connecting them together into systems.

Now, these are systems where one skill builds your brand context, another researches trends, another is writing the content from that knowledge, and then another runs everything automatically on a schedule.

And at that point, Claude isn't just helping with tasks, it's running entire parts of your business.

So I've spent hundreds of hours now inside of Claude Code building and testing this approach, studying Anthropic's frameworks, experimenting with community builds like Open Claude.

And building 20 plus production skills that now run my marketing, strategy, operations, and all creative assets.

And what that turned into is something much bigger than a collection of skills, it's an Agentic Operating System.

A system that knows your brand, runs real business tasks across departments, improves from your feedback, and maintains itself automatically.

So in this video, I'll show you exactly how it works, the architecture behind it, how skills chain together to run real business tasks.

And how the whole system learns and improves the more you use it.

I'm going to break down every layer so you can either build your own or just grab ours and start running from today.

So let's start by talking about building skills in the right way.

Because once you understand this structure, everything else starts to fall into place.

So a skill is literally just a folder made up of two things.

The first is the step-by-step instructions or the process documentation.

And that is in the skill.md.

And then the second, the bit that actually makes your process yours, is the deep knowledge that supports it.

So this is the references, the assets, and the scripts.

That also support that step-by-step instructions.

And you can think of those like your brand voice or example outputs that you like.

That you would put into a traditional LLM prompt.

And ultimately, it's the context in these deep knowledge files, the reference files, that make the process yours.

And here's the thing most people don't realize about the skills you download or import from somewhere else.

Like a skills marketplace.

They're designed to be generic on purpose.

So when you grab a skill from GitHub or a skills marketplace, it's never plug and play.

It always needs you to fill in the gaps with your own business knowledge.

You can of course use them without that.

But you're going to get poor quality outputs or generic outputs.

So let me show you a real example.

This is my marketing copywriting skill.

And if you take a look at the skill.md, you can see it points to other reference files.

So here we're pointing to brand context.

Which is basically saying, go read the voice, go read the ICP about our customers.

And also go and read the samples of good outputs.

And all of that lives in a shared brand context folder.

Stored down here.

And every single skill can access this brand context folder when it needs it.

So when this skill runs, it's not guessing how I sound or who I'm writing for.

It already knows all of that and it's pulling from real files with real data about my business.

That we loaded up when we started the system.

So having one skill turns Claude from a general assistant into your domain expert.

And it might write great copy at this point, but it still doesn't know your audience.

It doesn't know what worked and didn't work last time.

And that is where we introduce the operating system part.

So if shared context is the starting point of a system, the question then becomes, how do you actually build all of that brand context in the first place?

You don't want to be pulling it manually from all of your different business systems.

And this is where the Agentic OS does something really smart.

You just need one command once you've got the files.

You type in start here.

And the system's going to do the rest.

You can see we don't have any brand context already.

Because we actually need to create it.

And what happens next is it asks you a series of questions about your business, about your audience, how you want to sound, what makes you different.

And behind the scenes, it's not then just going to save your answers, it's going to go away and run our dedicated skills.

That analyze what you've told it and build proper structured files from your responses.

And those files get fed into all the skills going forwards.

So it's a one and done approach.

And there are actually three foundation skills that do their heavy lifting here.

One for brand voice extraction, one for positioning, and one for your ideal customer profile.

So these aren't just boilerplate templates, they're skills that actually interview you, process what you say and output real, detailed brand documents.

That can then feed in as that deep knowledge.

And when it's done, you've got a full brand foundation sitting in your brand context folder.

Your voice profile, so every skill knows how you sound.

Your positioning, so it knows your market angle.

Your ICP, so it knows exactly who you're talking to with every piece of comms you write.

As well as samples and examples from your real content, your gold standard stuff.

And then finally an assets file with your links, your handles, your visual brand references too.

And these are just saved as readable markdown files.

So you can open them, you can edit them, you can tweak them.

But the important thing is every single skill in the system reads from these same files, so your copywriting skill, your content repurposing, your UGC scripts, your trending research.

All pulling from the same source of truth, one shared folder.

And that's the first layer of the operating system, shared brand context.

But knowing your brand is static, it's a snapshot.

The second layer is what makes this thing actually feel alive.

Because the system doesn't just know your brand.

It learns how you work too.

So most AI setups are frozen in time, you build them and they stay exactly as they are.

But building an Agentic OS is different because you want it to have that second layer alongside the brand context.

And that's a context folder that's inspired by how Open Claude actually manages its memory and manages its functions around the user itself.

And this is what turns your skill collection into something that genuinely starts to understand you.

So let me show you what's in here.

First, you've got soul.md file and this is the agent's identity, how it behaves, how it communicates, what it's prioritizing.

Then a user.md file and this is about you, your preferences and your working style.

How you like things structured.

So when you tell the system you prefer concise bullet points over long paragraphs, it's going to always remember that and save that in your preferences.

And don't forget every skill is reading this too.

Then you've got things like the memory MD, which is for long-term business knowledge.

But most importantly, we've got short-term memory too.

So inside the memory folder, we've got these short daily memory files.

So the system has a log of what it worked on yesterday, what it produced last week, what's in progress right now.

So when you start a new session, you're not starting a new session.

You have some continuity.

It knows what happened in that last session and you can pick up where things left off.

And then the part which I think is the most powerful.

Which is learnings.md, and this is the system's long-term feedback memory.

So after a major deliverable or working with Claude Code for a day.

Skills are going to get your feedback.

Was the research we did useful?

Was the newsletter too long?

And whatever your feedback is, it's going to get logged under that skill section and then at the end of the day, those are going to get taken to update the skill.md files too.

So what it's doing is actually learning and maintaining the skill.md file too.

And next time the skill runs, it's going to read always its own learnings first.

We've built the skill creator to read these learnings first.

So finally, we're hitting a point where there's no repeating yourself and no having the same conversation twice.

So if we zoom out a little bit and think about what's happening here, the brand context folder tells skills who you are and who you serve.

The context folder on the other hand tells skills how you work, what's happened recently, and what you've liked and disliked.

That's a system that understands your business and is getting sharper every single time you use it.

So think of brand context as the snapshot and the context folder as the ongoing relationship that you have as you work with this tool.

And together they're why this system feels like it actually knows you.

But how then is this actually all keeping in sync?

As your system grows, things start to change, right?

You add new skills, remove skills, connecting new tools.

And in most setups, that means you're manually updating the docs, making sure nothing's broken.

But the Agentic OS, you should build so that it handles all of that itself.

So the way we've built it is every time we start a new session, the system runs what we call a heartbeat.

Which you might recognize from Open Claude setup.

So it scans the skills folder and compares what's actually on disk against what's documented in your Claude.md and your readme file.

So if you've added a new skill folder since the last session, it will adapt to that.

It registers the new skill, updates the context matrix, adds a section in your learnings.md.

You don't have to touch anything.

So every time you start a session, it's going to be learning exactly what you've added or taken away from the system.

It doesn't just extend to skills, it's MCP servers.

Anything you add to the system, it's actually going to understand the context of what's been added and why and then interlink those between your system.

But the really clever part is what happens when you build a new skill.

The common thing with skills is installing too many and having overlapping skills.

So before the system creates anything, you should make sure it reads every installed skills front matter, mapping overlaps, checking for dependencies.

So that the new skill fits cleanly into the existing ecosystem instead of duplicating or actually crossing over with what's already there.

And then at the end of the session, the same sync needs to run again.

And we've done that through a wrap-up skill.

So we've got a specific skill that we've adapted here, called wrap-up.

Which effectively is a checklist that reviews what deliverables we've created.

It's going to collect feedback, it's going to fix skills and update learnings.

And then finally, it's going to commit all the work that we've done.

So at the end of the session, we just need to say something like close session or wrap things up.

And it's going to trigger that and sync the full process for us.

And make sure that heartbeat runs again.

So we're starting to reach a point actually where we never have to update a registry file again.

We never have to sync docs.

The system actually starts to maintain itself, so you can focus on using it and not just babysitting and actually updating static docs.

So we've got a shared brand context, a learning system, and even self-maintenance.

But I've been talking about individual skills this whole time.

But the real power isn't in any single individual skill, it's in what happens when the skills start to work together.

And this is the level that turns a collection of skills into an actual operating system.

Because individually, each skill is powerful, but when they actually share context, feed into each other's process.

And operate as one connected system, it turns these from skills into actual workflows.

So let me show you what this actually looks like.

So in the Agentic OS, we've got foundation skills that run first and build that share context.

So this was our brand voice, our ICP, and our positioning.

Which work together to build that brand context.

We've got execution skills for things like copywriting, creating UGC scripts.

Actual UGC videos or images.

We've got strategy for things like trending research so that we can feed into our content pipelines.

And you can see that all of these skills are organized by category here.

And they interlink between those categories.

And then we're starting to even build out some ops or cron jobs to actually create workflows from these skills.

Using Claude Code's latest features.

And the real power is when you start to chain these skills together.

The trending research skill could go out and find what's getting engagement on Reddit and X this week.

It's going to produce a research brief and save that to the project folder.

Our content repurposing system might go out and find our latest YouTube video, create a newsletter from that.

And then bring in the trending research to make sure that we're hitting multiple angles in that content repurposing.

And during that, it's using various tools, it's using a humanizer to make the content sound less AI slot.

And it's also using the YouTube tool to actually go and transcribe.

So all of these are working together in unison as a workflow.

And by the way, when you install one of these, it understands the dependencies.

And installs the relevant sub skills which are actually dependent on it.

And of course, every step we talked about was also informed by the brand context.

And refined by the learnings in the previous run.

So you can see how this starts to become one system rather than individual skills completing tasks on your behalf.

So think about what this will mean for a business owner.

So you're not going to be managing 20 individual tools, you're effectively running a system now.

So your marketing, your strategy, your operations, and all your creative are sharing the same brain and understand your goals.

So connected skills are transformational.

That is what really pulls together this into an Agentic Operating System.

So now we've spilled all the secrets on how you'd actually build this out for yourself.

The question is, what are the ways you can get started?

Well, there are kind of two parts from here.

Everything I've shown you in this video, you can set up from scratch using Claude Code.

This is exactly how we've built it over weeks and months.

We've started with the brand context.

You're going to run through the foundational skills that capture voice, that capture your ideal customer profile, that question the user.

You can then start to build out your execution skills.

Things like your trending research, your content and your copywriting flows.

And then you would start to add the learning loop so that each of the learnings.

Feedback into every skill that we've got here.

And that way works and you will learn a massive amount doing it.

You can follow this exact framework to build a system like this.

Or the second path is actually you can just download it.

So the full Agentic OS, every skill, every reference file, the brand context system, the learning loop, the self-maintenance, the heartbeat, all of it that we've mentioned is available inside my community.

Which is linked in the description below.

You can literally join, download the repo, you run the start here command, and by the end of the day, you've got a full working business OS personalized to your brand that you can add or take away skills from.

All of these skills, by the way, are built in a consistent format.

And every time you add a new skill, it will reformat it so you've got it in a clean, readable format that feeds into your system.

So there you have it, skills on their own are powerful.

But connected together with shared brand context, a learning system that remembers your feedback, self-maintenance that keeps everything else in sync.

And skills that actually chain together as one system.

That's a complete operating system for your business.

And that's how smart people are using Claude Code skills to automate anything.

Thanks so much for watching, if you want to understand how to build out skills in more detail.

Then watch the next video.