Big Idea

The argument in one line.

Claude Code unlocks its real value not through casual chat but through skills that encode repeatable workflows, MCP servers that extend its reach into external tools, and a markdown-based memory architecture that persists across sessions.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You have shipped at least one project with Claude Code and feel like you are only using 20 percent of what it can do.
You find yourself re-typing the same detailed prompt instructions in every new session.
You want Claude to autonomously create GitHub repositories, push code, and run browser-based tests without manual steps.
You are curious how sub-agents, parallelism, and scoped tool access actually work under the hood.
You want a visual layer on top of the terminal for session management, diffs, and Kanban tracking.

SKIP IF…

You have never opened Claude Code before -- start with the beginner tutorial linked at 00:58.
You are looking for model pricing comparisons or benchmark deep-dives rather than workflow architecture.
You already run a mature CLAUDE.md and skills setup and want content beyond the fundamentals covered here.

TL;DR

The full version, fast.

Most Claude Code users operate at 20 percent capacity because they skip configuration. A handful of CLI commands control token spend and surface usage intelligence. MCP servers extend Claude into external systems. Custom skills are markdown files in .claude/skills/ that register as slash commands and auto-invoke when relevant. Sub-agents parallelise independent tasks with their own context windows. And CLAUDE.md is the only default persistent memory -- the advanced form is a whole workspace directory of markdown files Claude reads contextually.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:45

01 · Overview

Promise: show a real intermediate/advanced setup. Beginner tutorial linked on screen.

00:45 – 04:50

02 · Useful Commands

/model, /insights, /cost, /context, /compact -- what each does and when to use it.

04:50 – 09:57

03 · Adding MCP Servers

GitHub MCP via terminal command with --scope user flag and a personal access token. Scope hierarchy explained. Testing with /mcp.

09:57 – 13:21

04 · Adding Plugins

Context7, Superpowers, and Playwright installed via Claude Desktop personal plugins panel. Syncs into Claude Code automatically.

13:21 – 20:56

05 · Custom Skills

Skills as markdown files in .claude/skills/. Live demo: build a code-review skill from a pasted template; it registers as slash command and auto-invokes when task matches.

20:56 – 25:44

06 · Nimbalyst

Free open-source visual layer. Kanban board, markdown diff viewer, custom project extensions, mobile app. Sponsored segment.

25:44 – 33:08

07 · Sub-agents

Built-in vs custom agents, /agents creation flow, tool scoping, parallelization pattern. Custom test-writer agent walkthrough.

33:08 – 37:40

08 · Memory Architecture

No default persistent memory. CLAUDE.md at project and global level. Multi-file workspace directory pattern sourced from OpenClaw.

Atomic Insights

Lines worth screenshotting.

Claude Code ships with /insights, which generates a full local web report on your usage patterns and mistakes -- most users never run it.
Every unused MCP tool loaded in a session consumes tokens silently; a full Zapier connector bloats context even when you never call it.
A Claude Code skill is just a markdown file in .claude/skills/name/SKILL.md -- no runtime machinery, no special syntax.
/compact summarises your session rather than clearing it, letting you continue near the context limit without losing thread.
GitHub MCP needs --scope user at install time or it only works in the one project where you added it.
Custom skills auto-register as slash commands after a session restart -- no manual wiring required.
Claude auto-invokes a relevant skill when you describe a task that matches -- you do not need to type the slash command yourself.
Sub-agents inherit the parent session tools by default but can be restricted with tools or disallowedTools in their frontmatter.
CLAUDE.md is the only persistent memory Claude Code has -- if something is not written there, the next session starts completely blank.
You can stack a global CLAUDE.md with a per-project one; Claude reads both at session start.
The most effective memory pattern is a whole workspace directory of typed subdirectories rather than one monolithic CLAUDE.md.
Telling Claude to spin up N sub-agents for N parallel tasks usually outperforms trying to engineer a single perfect prompt.
Skills created at project level are invisible outside that repo; move them to the global skills folder to make them available everywhere.
Switching from Opus to Sonnet mid-session is one /model command -- the fastest way to stop burning credits on simple tasks.

Takeaway

How to get full leverage from Claude Code.

WHAT TO LEARN

The gap between a 20 percent user and a power user is not skill -- it is configuration: skills, MCP, and memory architecture that persist across sessions.

Run /insights before anything else -- it generates a personalised report on your usage patterns, including where you waste tokens.
Check /context in any long session; unused MCP tools consume tokens on every request even when you never call them.
A skill is just a markdown file -- write the workflow you repeat most often, ask Claude to document it in .claude/skills/, and it becomes a slash command.
Claude auto-invokes skills when a task description matches the skill name; you do not need to type the slash command yourself.
Install persistent tools like GitHub MCP with --scope user or they disappear when you switch projects.
CLAUDE.md is the only memory that survives a session close -- anything not written there starts blank next time.
The advanced memory pattern is a whole workspace directory (docs, memory, state) rather than one file; Claude reads named files contextually.
Sub-agents shine when you have N independent file-level tasks -- tell Claude to spin up N agents rather than working sequentially.
You rarely need to create custom sub-agents by hand; Claude builds better ones than most users do when given a task description and asked to persist it.

Glossary

Terms worth knowing.

MCP server: A connector that gives Claude Code the ability to act in external systems (GitHub, Notion, Playwright, etc.) beyond its built-in tools. Configured by scope: local, project, or user.
Skill: A markdown file stored in .claude/skills/name/SKILL.md that documents a repeatable workflow. Claude registers it as a slash command and can auto-invoke it when a task matches.
Sub-agent: A separate Claude instance with its own context window, spun up by the main session to handle an isolated task in parallel. Can be built-in (Explore, Edit) or custom-defined.
CLAUDE.md: A markdown file that Claude reads automatically at session start. The primary mechanism for persistent memory -- anything not written here is forgotten when a session ends.
scope user flag: A CLI flag used when adding MCP servers that makes them available across all Claude Code projects on the machine, not just the current repo.
compact command: A Claude Code slash command that summarises the current conversation into a compact form, freeing context window space without losing session continuity.
Context7: A free MCP plugin that injects live, version-specific library documentation into Claude Code sessions, preventing outdated API hallucinations.
Nimbalyst: A free open-source visual IDE layer for Claude Code with a Kanban board for session tracking, a markdown diff viewer, custom project extensions, and a mobile companion app.

Resources

Things they pointed at.

20:56toolNimbalyst ↗

10:40toolContext7 MCP ↗

11:42toolSuperpowers plugin

12:10toolPlaywright MCP

34:50toolOpenClaw

Quotables

Lines you could clip.

00:08

“Most people open up Claude Code, start chatting with it immediately, and only realize about 20% of what it's actually capable of.”

Instant pattern interrupt, zero setup needed→ TikTok hook↗ Tweet quote

13:41

“All that a skill is is really just a markdown file -- a fancy formatted text file that explains to Claude a step-by-step process.”

Demystifies the scariest-sounding feature in one sentence→ newsletter pull-quote↗ Tweet quote

25:56

“You don't really need to create your own custom sub-agents because if Claude needs one, it's usually better at creating its own custom sub-agent than you would be.”

Counterintuitive -- gives permission to not over-engineer→ IG reel cold open↗ Tweet quote

33:12

“Anything that you want to save has to be written down and typically saved in some kind of markdown or documentation file.”

The entire memory architecture thesis in one sentence→ newsletter pull-quote↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

metaphorstory

00:00Most people open up Claude code, start chatting with it immediately, and only realize about 20% of what it's actually capable of. So in this video, I'm gonna give you a slightly more advanced Claude code tutorial where I show you my real professional setup and we go over things like creating skills, sub agents, connecting to MCP servers, and just overall build a much deeper understanding of how Claude code works so you can utilize it in your workflow better.

00:26Now one thing to notice that what I show you here may not be what you need for your workflow, but it will show you how to set it up so that you can customize Claude code because that's where it becomes extremely powerful. So with that said, let's get over to the computer and let's start looking at some more advanced Claude code features so you can get much more productivity and benefits from it.

00:45Okay. So I'm on the computer now, we're gonna dive in. Now I'm sure at this point that you probably already know how to run Claude.

00:51If you don't and you've never seen Claude code before, you don't understand the basics, then you'll definitely wanna watch this video first. I'll put it on screen and link it in the description, which goes over everything you need to know in terms of installing it, setting up all of the basic stuff, whereas this is gonna be more of an intermediate or advanced tutorial for those of you that already know the simple stuff.

01:10Okay. Now with that in mind, let's pop into Claude code here. And the first thing I wanna do is just have a look at a few commands that you need to be aware of.

01:17Now depending on the type of plan that you're using, you likely do wanna change the model that Claude is using depending on what it is that you're doing. So you can run this slash model command, this will allow you to switch between the different models.

01:29Now I know a lot of you know that, but especially if you're on the $20 per month plan, you definitely don't wanna just be using Opus by default because it's really overkill. It costs a ton of money, and you're gonna get significantly more usage if you switch to something like Sonnet or even Haiku. Sonnet is just a default model that we should work for most tasks, Opus for something more complicated, and then Haiku when you wanna do something sim simple or generate a bunch of data you wanna do like a long running task that, you know, you don't wanna use all of your usage up for with HiQ or with Opus.

01:58Sorry. So just switch between these and make sure that you are kind of aware of what model that you're using because you can really quickly rip through all of the credits here. Even if you're on the max plan like I am, you can get, uh, out of the usage, you very, very quickly.

02:11Okay. Now continuing, another command that I recently found out about, which is super cool, is the slash insights command. And when you run this slash insights command, what it's gonna do is generate a full report for you on how you use Cloud Code, talk to you about mistakes that you're making, things that you're doing well, where Claude code is working for you, where it's not working for you, and generate a full web page with all of the results.

02:32You haven't yet, definitely take a look at this because it can be really insightful, hence, slash insights. Once it finishes generating, I'll show you quickly what mine looks like, and then we'll move on. Okay.

02:42So you can see that it's generated this report for me. It's just in a local file. So in order to open that, you can just go into, like, a Chrome tab.

02:49K. This is just my reference file. Let's open this up, and you can see that it shows you everything here.

02:54I'm not gonna go through my full usage here, but generally speaking, you can see that gives you a really detailed guide with a ton of graphs and charts and messages and at a glance what's working, what's not working, etcetera. So have a look at that, and I guarantee you're gonna learn something. Now a few other commands you wanna know.

03:08First slash cost. So if you are running on some kind of API, you can run this, and it will tell you how much it's costing. In my case, it's free because I'm just using the subscription.

03:17And then the slash context command is also a really useful command. What this will do for you is show you all of the things that are being used in your current context and give you a sense of kind of what percentage of them are from what different sources. And, again, especially if you don't wanna run out of the usage, which is important, you should check this especially in longer conversations.

03:36And you can see that we've used 25,000 of our 1 million tokens. You can see the system prompt, 6.9, system tools, skills, messages, free space, all of this kind of stuff.

03:47And then it shows you all of the MCP tools that are being loaded in here. And you'll notice that depending on what MCP provider you're using or how you set up MCP, you may have a ton of tools here that are being loaded in you just don't need.

04:01So I would highly recommend disabling tools that you're not using in a session because that will save you a lot on the context and also just make Claude code be a little bit faster and easier to run because it's not gonna be searching through a ton of tools that you just aren't actively using. Like in my case, have all these Zapier tools where, like, I'm not actually using them right now and they're just bloating the context and potentially confusing Claude code.

04:22Now the last quick command to go over here is slash compact. What this is gonna do is clear the current history that you have to keep a summary of that in the context. So if you're getting near the context window or you just don't want it to be as expensive because the context window is quite large, you can compact this.

04:37Again, what it will do is summarize the current conversation and include a small amount of tokens in this session so that you can keep going with the same session without losing everything. Compact is not always the best strategy, but it's just a command that you should be aware of.

04:50Okay. So those are a few basic commands. The next thing that I wanna go over is adding MCP servers.

04:55Now MCP servers really make this significantly more useful, and there's a few different ways that you can add MCP servers to Cloud Code. Now if you're directly inside of the terminal here, can run the slash MCP command where you're able to see all of the different servers that you have. You can see I have some enabled, disabled, right, you know, automatically built in, etcetera.

05:13And the one thing that you need to be aware of is that when you add MCP servers, you can add them at a project level, at a user level, or at a global level. And that's kind of the same with everything that I'm gonna show you in this video. You can create something per a specific project, or you can make it locally or sorry.

05:30Globally for your entire Cloud Code instance. So just be aware of when you're adding these and the scopes in which you're creating these different tools because if you want it to be global, for example, but you just add it in the project, then you won't see it in other Claude code sessions. The way this works is that Claude is automatically gonna create a folder called dot Claude inside of the project where you're working with Claude code.

05:51So let me get out of this here. Let's just type l s. Okay.

05:53I guess it's because we're in Claude. It's not directly executing it, but it should show us the current files that we have. And I don't know if we already have a dot Claude folder, but if not, if we start making any changes, it will automatically add it.

06:06Okay. So it looks like this folder is empty. But if I just exit out of Claude code, let me just c d into one where I know we're gonna have a Claude code directory.

06:13So that's l s. Let's c d into maybe our dev projects.

06:19L s c d into, and we'll go to the velocity one. And you'll see here if I do l s dash a, just because it's a hidden folder, we have this dot claud folder. And then if I c d into dot claud, same thing, l s dash a, you can see we have a settings dot local dot JSON.

06:33We We don't need to have a look at that file, but the point is that anything that's specific to a project you're working in will go in this dot clawd folder. So just be aware of that because if you add an MCP server, for example, by default, it just adds it to the project. It doesn't add it to the global scope.

06:48You need to change that when you're adding the server, which I'm gonna show you here in a second. So let's c d back into our desktop and c d into the demo that we have here.

06:58L s run claud, and we are back to go here. Okay. So as I mentioned, what we wanna do is add a few MCP servers.

07:04Now the first extremely useful MCP server to add is the GitHub MCP server. The reason you want that is because you want Claude to automatically be able to create remote GitHub repositories and push the code there for you.

07:16Yeah. Sure. You can do it manually.

07:18It's not that much work, but generally having GitHub MCP just makes your life a lot easier. So let me show you how we add that, then we'll look at the next one. Okay.

07:25So I'm gonna leave a link to this page in the description, but the easiest way to add the GitHub MCP server is to run a terminal command. This is what the command looks like right here, claud add or claud m c p add JSON GitHub, and then you put in all of this and you replace your GitHub PAT with your GitHub personal access token, which I will show you how to get.

07:44Now we also can have a look here and notice about the scope. So as I was mentioning, it's gonna scope to local by default, which means it's only available to you in the current project. Okay?

07:54Then you can scope it to a project, so it's available to everyone in the project versus dot m c p dot JSON, or you can scope it to user, which is effectively global where it means it's available across all of the projects.

08:06For something like GitHub, you probably want it available across all of the projects, So would add this dash dash scope user to this command right here. Now the way that you can get the personal access token, let's just open up a new window here so we can save that command to copy later, is the following.

08:23You're gonna go to your GitHub account. Obviously, you need to have one. You're gonna go to your where is it here?

08:29Settings. You're gonna scroll down to your developer settings. You're gonna go to personal access tokens, fine grained token, and then you're just gonna create a new token.

08:39So you go create new token, authenticate, specify the scopes you want it to have access to.

08:44Typically, it just needs access to the repo, and then it will give you that PAT. I'm not gonna do this because I already have the MCP server added, but I'm gonna show you now what you would do. So now what you do is you essentially take that token that you generated and replace it in this command.

08:58If you're unsure of how to do that, just open up some kind of notepad. So I would just paste this command in your notepad, and then you take this and you say, you know, this is the token. And you just push paste the token there, and then you run this command directly in your terminal.

09:10So what I mean by that is you literally just open up a new terminal, don't run it in Claude code, so get out of Claude code first, and you just directly run it in the terminal, not inside of Claude code. And then same thing, you could add dash dash scope, and then you can say user, and this will install it globally for you.

09:25So that's how you add the GitHub MCP server. And then if you wanna test if the MCP server is working, same thing, you can just restart Claude. From here, you type slash m c p, and then you should see the GitHub is connected.

09:37And then you can go here and you can view all this stuff. You can re authenticate, reconnect, whatever.

09:41And once you add the GitHub server because you're using the personal access token, you shouldn't need to do any OAuth thing. It should just be set up for you. Okay.

09:49So that is the first thing that you wanna install, GitHub MCP. Now the next thing that I'm gonna recommend adding is the context seven MCP server. Now it's much easier to install this if you just open up the Claude desktop application.

10:02Now this will sync with your Claude code. So you can have Claude code installed and then download the Claude desktop application. From here, let's just go back to a new session.

10:11You're gonna go to the code tab at the top. You're gonna go to customize, and you're gonna go to personal plugins. Now from personal plugins, what you're gonna do here is browse plugins, and you're gonna search for a plugin called Context seven.

10:25Now I believe I already have it installed, it's not showing it to me. Let's see. Context seven.

10:28Yeah. It's because I already have it installed, but essentially, you're just gonna install the Context seven plugin, which looks exactly like this. What this does is give your Claude code access to live up to date documentation.

10:39It's free. You don't need to pay for it. And then there's a few other connectors or plugins you can add.

10:44For example, one that's pretty cool is called superpowers. This is something that's gonna give your quad code just a better ability to create large applications.

10:52It does use a lot more context and is a lot more expensive. So I would only recommend having this if you have the max plan. But, essentially, this comes with some prebuilt agents as well as some prebuilt skills to do things like brainstorming for a new idea, creating a mock up, reviewing the code.

11:08But, again, it does slow down Cloud Code a lot, which is why I have it disabled right now. And then the last plugin that I've installed is called Playwright. Again, these are just you can find them by default in Cloud Code.

11:18It's just because I have them installed. They're not showing up again. But you can search Playwright and it will appear.

11:23Same thing. You just install it, and then automatically these will be added to your Cloud Code. What Playwright will allow Cloud Code to do is browser automation, so it can automatically test websites that you create by itself by running Playwright scripts and spinning up a Playwright browser instance.

11:38Not gonna get into how that works exactly, uh, but you can kinda get the idea there in terms of why those connectors are powerful. Okay.

11:45So those are two connectors, GitHub MCP and then the Context seven. And if you wanna test if they're working, just say something like, create a new Git repo here and then create a new remote Git repository repository and just push a README file saying this is a demo application to GitHub.

12:00Okay. We're gonna go ahead and press on enter if my dictation will load.

12:05Of course, it's being slow. Okay. So there it is.

12:08Let's go ahead and hit enter, and then it should have access to the GitHub MCP tools here in order to do that, and it should be reading through the available tools. And then if we want, we can change the mode here to just auto accept edits by hitting shift tab on your keyboard. So if you hit shift tab, you'll see that you can change between accept edits, plan mode, or just the default mode.

12:26So I'm just gonna put accept edits on so that I don't need to keep accepting all of the edits that it's making, uh, and then it should be able to do this. Now it's saying the command g h is not found, but that's fine. It should default to use the MCP server.

12:37Sometimes it can be a little bit stupid, so you just have to direct it, hey, use the GitHub MCP server, and then it should use that. Okay. So we can see here it's now found.

12:45Okay. I don't wanna use g h. I'm gonna use the GitHub MCP server, and it says I wanna create a new repository.

12:50So go ahead and press on yes, and then it should be able to call that tool and complete that action. Okay. So it's saying this is live.

12:56So what I'm gonna do is just open this up in my browser. Okay. Let's go here and let's see.

13:04And we see we have the remote repo. I didn't have to touch this. Claude just did that for us automatically.

13:09Okay. Cool. So now we're connected to GitHub.

13:11Also, if you wanna go even further, you can give your Claude code its own GitHub account, although in my case, there's no need really to do that. And what we're gonna do is move on to talk about skills. Alright.

13:21So I'm just getting Claude here to generate a simple application in this directory so I can start showing you skills in a little bit more of a practical demo. But effectively, what a skill is is a learned behavior from Claude. So we just added MCP servers.

13:34Right? What MCP servers allow Claude to do is take additional actions that it doesn't normally have access to. So we could connect it to Notion.

13:43We could connect it to Google Drive. Right? Any place where we want Claude Claude, sorry, to be able to take an action.

13:48From a developer setting, usually, you know, a thing like GitHub makes a little bit more sense. Now let me just go ahead and accept that. Now when we talk about skills, skills are not really actions that Claude code is taking or, like, a tool that it's calling.

14:00It's more so a behavior that it's learning how to do or that it's learned how to do and it's documenting itself. All that a skill is is really just a markdown file, and a markdown file is just a fancy formatted text file that explains to Claude kind of a step by step process that it should follow. So when people start talking about skills, really all they're saying is, hey.

14:20We have this workflow or this repeatable thing that we do a lot. So rather than just prompting Claude and explaining to it over and over again to keep doing the same thing, we can wrap that kind of workflow or repeatable task in a skill, which is effectively just a file. I'll show you exactly what it looks like in a second.

14:35And then when we wanna do something in the future, we can just reference that skill and Claude code will execute that. So that's literally all a skill is and skills become useful when you actually use them inside of a project to do something repeatable. So for example, if you're always, you know, changing some line in a file whenever something updates, maybe that's a skill you create for Claude.

14:56If you wanna review the code in a certain way where you're looking for maybe things that Claude doesn't do by default, you create a code review skill and then you point to it. If you want a certain deployment step where Claude, you know, runs a few build commands and then execute something for you, then that's a skill, right, that you can give to Claude.

15:12So what I wanna do right now is I wanna show you how to create your own custom skill, exactly what the skill looks like, and then how to use it and invoke it. Alright. So before we do the skill, I wanna show you the difference between a prompt with and without the skill.

15:25So right now, have some code generated. Right? We're not really looking at it, but if I do l s, uh, maybe it will give me a quick look at the project structure.

15:32And what I just asked them to do is create, like, a simple API with Express that just represents, like, a basic library with, you know, books, update a book, delete a book, all of this kind of stuff. Now running the command directly inside of Cloud is really not the best because it's not giving me the output that I wanna see.

15:47The point is we have a bunch of files now. Right? So what I could do is say something like, hey.

15:50Review the code and give me an analysis of it. Now if I do this, like, that's fine. Obviously, it's not very detailed prompt to what I'm asking it, uh, but it should be able to review the code and it will give me some kind of answer.

16:02The issue with this is that if I want the code reviewed in a certain way, I'm gonna have to write this, like, really detailed prompt. I'm gonna have to remember what the prompt is. I'm gonna have to do it again over and over again.

16:12And you can see that the way that it's reviewing it is fine, but it's probably not the format that I'm looking for or what I wanna consistently get. So rather than trying to, you know, mess with Claude every time and come up with the perfect prompt and save it in a notepad and, you know, use it again, we just create a skill.

16:28So to create the skill, we can literally just tell Claude to create one. Hey, create a new code review skill, and then we can tell it what we want the skill to be. Now the benefit here is that you can actually have Claude code make these skills completely for you.

16:42And if you just give it enough detail on what you want, then it will document the process and make the skill. Then you can run the skill and you can tell Claude Code to continually improve the skill until you get it to a place where you're happy and then it doesn't need to touch it. So what I'm gonna paste in here is just an example of what a skill could look like.

16:59You don't need to write this from scratch. You can just have Claude Code make it. So I'm just gonna paste, uh, what is it?

17:06This skill, I have one that I copied here, and let me just enter that in the middle. And this is kind of what it might look like. So name, code review, description, structured code review following team standards, and then it says follow this structure.

17:19Security, error handling, performance, code quality, testing for each finding, you know, give a severity, location, whatever.

17:26So this is the format that I want the code review to be in. And you can see that right now what it's doing is it's looking up the documentation on how to create a skill, then and it will make a new one for me, and it should just enter that into the skill file. Okay.

17:37So you can see what's happened here is it says, hey. We're gonna create a new file. The file is called skill dot m d.

17:43It sits inside of the code review folder, which is inside of the skills directory inside of the dot claud folder. So as I talked about before, you can have project and you can have global configuration. By default, when you make a skill, it's gonna create it in the project level, not in the global scope.

17:59So it's creating this dot claud folder, which is sitting in the local project repo. We then have a folder called skills. That's where all of the skills go.

18:06And then we have a skill called code review and skill dot m d. Now skill dot m d is just the format for where this skill should go.

18:13And then inside of this file, if you had any scripts or other documentation, you could put them here and just understand that Claude will read this skill dot m d file first. And then from the skill dot m d file, you could reference other things that are inside of this folder.

18:26So let's go ahead and press on yes and just have it generate this skill and then I wanna test it out. Okay. So we can see that it's been created here.

18:33And now if I wanna use this skill, what Claude will do automatically when you put it in this type of format is create a slash command that you can run. So I can actually run slash code and then review it like so. And it's saying unknown skill.

18:46I might just need to restart the session here for it to pick it up, but that should have worked. So let's just restart this. So slash exit.

18:53Okay. And then let's just go to Claude. And then what we can do is say slash skills.

18:58If we say slash skills, okay. Now we can see code review. And then what I can do is directly invoke the skill by doing slash code dash review, and there we go.

19:05It now appears. I just had to restart the session. So now if I do the code review skill, I can also pass a prompt with the code review.

19:12So I can say slash code review and then tell it something to review, or in this case, generally review the whole code base. And now you can see that it's giving it to me in the exact format that we want where it's showing us security. Right?

19:22And then let's wait a second. It shows us the error handling, and we get exactly what we were looking for because we've bundled it in this personal custom skill. So you should be creating a lot of different skills, make them at a project level, make them at a global level.

19:35If there is a skill that you want to be at the global level, you can simply just tell Claude Code to put it there. So say, hey. I wanna move this skill to the global level.

19:43Okay. Let's give it a second here. It's being very slow because my Internet is really bad, and then it should just be able to automatically move it there for you.

19:49Okay. So you can see it's asking to move it to the global level, which is inside of just my home folder and then dot claud, whereas this claud folder is just directly inside of my local directory. I'm just gonna go no because I actually don't wanna do that, but you get the idea.

20:01Okay. That's how you could move this skill to the global workspace. Now there's a lot of other skills you should be creating.

20:08Generally speaking, when you do something a lot, wrap it into a skill, ask Claude Code to build the skill for you, review it, read it, make sure you understand it, and then adjust it as needed, and you're gonna get a lot better performance out of Claude Code. Now it's also worth noting that Claude can automatically invoke these skills for you.

20:24So while you can just run the command to execute the skill, you don't need to. You can just say something that would involve the skill being used, and Claude code will automatically figure out that it needs to call that. So if I just say something like, you know, review my code in the main files.

20:40I don't know. It should understand, hey. I'm doing code review.

20:43Let me look at the skills I have. Oh, I have a skill review or code review skill. Okay.

20:47Let's use that and then go and invoke that skill. And you can see it does that. Right?

20:51It's doing the code review skill, and it's giving me the exact same format as before, and that's the consistency that I'm talking about. Okay. So let's keep going here.

20:58I do also wanna dive into sub agents and a lot of other more advanced features like creating your own slash commands. But first, I wanna show you a visual way to work with Claude code because right now we're directly inside of the terminal, and it can be a little bit difficult to actually see and understand what Claude code is doing and to start digging into some of those files that it's creating.

21:17Now that's why I'm gonna show you this tool called Nimbalist here. This is what it looks like. It kind of looks like a traditional editor, but with a lot of other cool tools, and it's specifically designed to work with both ClaudeCode and Codex.

21:28Now it is completely free. It is open source. You can download it right now from the link in the description.

21:33They don't even have an ability to pay for it. I did team up with them for this video because it's a really cool app I've been using, and I think you guys are gonna get a lot of value out of it. Now I just opened another project inside of here.

21:44You can open up any project you want in Nimbus. You just go file, you know, open, and then you can just pick a project that you wanna open. And when you do that, what's gonna happen by default is you're gonna have your Claude code session appear on the right hand side of your screen.

21:58You also can just make a new one and then you get a new Claude code session, and you get connected automatically to the Nimblest MCP server, which allows you to utilize this really cool interface.

22:08So you can see, like, on the left side, you can see your Claude usage. You can see codecs. In this case, we're not connected.

22:13You can see various extensions, which we'll talk about in a second. You can change the mode. So I'm just allowing all, but you can change it so that, you know, it asks, allows edits, all of that kind of stuff.

22:23You can change the color theme. And then if you have a look here, you can view a Kanban board, which in my opinion is the coolest part of this, that shows you what all of your different ClaudeCode sessions are doing at any given point. So you can see that I have this little task right here.

22:37I can move it across to different portions. And if you're someone who's a ClaudeCode power user like I am in a lot of cases, if you have multiple sessions open, you can see them in all of the different status kind of lanes or whatever you wanna call it here so you can understand what's actually going on and really quickly switch between this view and all of the sessions you have to know, like, what's actually happening with your Claude code sessions.

22:59Now, of course, you can also view everything going on. So in this case, they have a really nice markdown viewer. So when you actually look at a markdown file, you can read all of the formatted markdown, not the raw text.

23:10And if you ask Claude to make a change, like, I let's say, I don't know, review my project guide and just make some small improvements. K. If I ask it to do that, we can actually view all of the diffs and changes that it's making to our files in real time, which is super cool.

23:26So you can see that I'm working with Claude, right, using it on the right hand side of my screen. And then again, if I want, if I go back here and I view the Kanban, you can see we're now in the inbox because I just sent the message, and this is gonna start getting moved automatically into the correct column. So you can see it's now in the implementation column even though I didn't refresh or do anything.

23:43And we can see that it's gonna start actually making changes, and we can view changes automatically right here in the browser and see or right here in the viewer, sorry, and see the markdown rerendering as well as all of the diffs, And we can approve them, keep them, whatnot, directly from here. So you can actually see if I start scrolling down here that it highlighted in red, the thing that's removing, and highlighted in green, the thing that's added.

24:04I can go between the different changes directly in the file to see any of the changes visually. And it's super cool that it works just directly here with all of the rendered code, so it's a lot easier to read, especially because markdown files are, you know, the common thing that you're working with when you're working with something like Clot.

24:19Few other quick things to mention, they also have these custom extensions that you can have. So what I actually have this do previously is I just said, hey, build a custom extension so I can view all of the documentation for my project in one clean interface.

24:33I just put that directly in the Cloud window here. And then Nimbus actually built its own extension. So now I have this, like, custom dashboard for my project where I can view the whole project directory structure, all of the stuff that's going on with all of the tags and whatnot directly inside of here.

24:49So it's kind of a little bit difficult to explain, but it's like an extension on top of Claude code that's specific to this project, the Nimbus just built. Now there's a lot of other cool stuff you can do in this, but generally, if you just want like a visual editor for Claude code, you wanna be able to view all the sessions, and to be honest, just the Kanban board alone makes it worth it to me because again, it's free, it's open source, you don't need to pay for it, and you can just visualize what's going on.

25:10You also can create different plans, have decisions, track bugs, you know, create tasks, all kinds of advanced stuff. I'm just really scratching the surface. And then last thing that I'll mention is they also have a mobile phone app.

25:21So what you can do is you can actually monitor all of your sessions and interact with Nimbus and your Cloud Code session directly from your phone if you just download the app. Again, all free, all open source. That's the only reason I'm mentioning it to you guys.

25:32If you find it useful, download it, check it out. You can start opening your Cloud Code sessions. If not, then no need to use it, but I'm gonna continue with this for the rest of the video as I start talking to you about sub agents and other more advanced features.

25:44Okay. So let's continue now and talk a little bit about sub agents. Now sub agents get confused quite frequently because there's multiple ways that you can use sub agents within Claude code.

25:54Now a sub agent is effectively just another AI agent that's running with its own context window outside of your main Claude code session. So right now, I'm in a session. Right?

26:04I've created a new session for Claude code. Now I could ask it to do something. That's fine.

26:08But I can also tell it to delegate a task to a sub agent or multiple sub agents. I'm gonna show you what that looks like in one second. Now when I do that, what's gonna happen is ClaudeCode will create multiple different versions of itself effectively that have their own context and their own prompt or kind of task they need to achieve and just go out there and achieve them.

26:28So that's the first thing that we're referring to when we talk about sub agents is these, like, multiple little agents that you can spin up to break down a task. Right? But you can also create custom sub agents.

26:40And when you create a custom sub agent, you can give it a set of instructions that it always follows and you can reuse that agent multiple times. So again, from your main Claude code terminal, you can tell it, hey, go use my code reviewer agent.

26:54Go use my GitHub agent. Go use my deployment agent. And if that's already created and set up, it already has a framework to work from.

27:02If you don't do that, Cloud Code creates the agent by itself based on what it needs to do. So I know it's a little bit confusing, but let's have a look at an example. So let's say I do something like, I want you to audit all of the documentation in this project and give me a concise summary on exactly what it covers and where there's gaps.

27:20I want you to spin up as many documentation files as there are sub agents so each agent handles tracking one documentation file, reports it back to you, and then you take the summary and give it to me. Okay?

27:34So we're gonna go ahead and press enter here, and then I wanna watch these sub agents spin up and kinda show you what this looks like, and then we'll create our own custom sub agent. Okay. So you can see what's happening is Claude is automatically creating a few Explore sub agents.

27:47Now these are sub agents that are actually or this is an agent framework, I should say, that's prebuilt into Claude code. So Claude code has a few prebuilt sub agents that it can trigger. It can also make custom ones.

27:58And in this case, we're using the explore one, and you can see multiple of them are spun up. And then if you go to this little tab here, you can see there's a sub agent tab. Okay.

28:05And you can see that it says zero out of five just because these are now done running. And if you wanna see what these sub agents are doing, well, you can actually just go click into it, you can view the prompt that Claude provided to the sub agent. And then what is it that they actually did, which is reading a README file, reading this whatever, going through.

28:20And then there we go. We get the little message here. Let me just close this README file saying that this is finished.

28:25And if I scroll down, it gives me a full complete list of what exactly was done, some major gaps, recommendation, etcetera. So this is cool.

28:34But, again, where this gets more powerful is when we make our own sub agent. Okay. So now let's move on to create a custom sub agent.

28:41Now sub agents are gonna live in this Claude folder here under an agent's directory, and they're gonna look almost the exact same as a skill. The only difference is that it's going to be its own agent effectively that can call other skills. Again, we'll dive into that in a second.

28:57Point is to make a new sub agent, we can go use the Claude code terminal. So I can say Claude, and then I can type slash agents.

29:04Then what I can do is create a new agent like this. I can pick, do I want it to be personal? Do I want it to be project?

29:11Okay. Then you can generate with Claude where you just describe what you want the agent to be or you can do manual, uh, what do you call it, uh, invocation here. So it's gonna say give an identifier for the agent.

29:22Let's go test writer. Okay. Uh, enter the system prompt for the agent.

29:27So I'm gonna paste in the prompt that I have here, which is going to look something like this. Now because we're going through this kind of interactive flow, I don't need to provide the top section.

29:38So I'm just gonna delete that when my cursor gets up here. Okay. Cool.

29:42So let's get rid of all of that because it's already gonna know what it needs to do. And then we should just be able to select the model that we wanna use, and we're good to go. So I'm just gonna say when should Claude use this agent?

29:52When you are writing tests. Okay.

29:56And then you can choose, do you want it to have access to all of the tools? Okay. So maybe I don't want execution tools.

30:02Alright. So I'm gonna hit enter on that and remove that. Do I want all tools?

30:05Okay. Do I want only MCP tools? Right.

30:07You can choose what you want the agent to be able to do. I 'm gonna press on continue, and then you can select the model. I'm gonna go with Sonnet.

30:15And for the color, let's go with orange. Okay. And then it's asking for the memory for this agent.

30:19So, again, it can have no persistent memory. It can have memory in the user scope, local scope, or project scope. I'm gonna go project scope, and then it shows me what the agent is gonna look like.

30:27I'm gonna press enter, and then the agent is now created, and we can start using it. Okay.

30:33So to use the agent once it's created, we effectively just need to tell Claude to do something that would utilize the agent. So if I say, hey, test the test writer agent, then it should just actually spin it up and start using it.

30:46So there's not a command that I'm aware of to manually invoke the agent, but Claude can invoke it by itself. So you can see now it's invoked test writer. The agent is going and executing and completing those different tasks on whatever it is that Claude told it to do.

30:59So the main difference between agents and skills is that agents are more flexible. They're general, and they're gonna follow the system prompting kind of persona that you've given them, whereas a skill is typically a workflow that an agent might use. So you might have a lot of different skills, but only like two or three agents.

31:15And to be honest, you don't really need to create your own custom sub agents because if Claude needs one, it's usually better at creating its own custom sub agent than you would be, And you can tell Claude to make the agent and just save it persistently if you want. So I wouldn't focus too much on making your own sub agents.

31:30I would just focus on instructing Claude to invoke multiple sub agents when necessary so it paralyzes the tasks. Right? Hey.

31:37You have six tasks. Go spin up six sub agents to do that. If you start telling Claude to do that, you're gonna get a lot better results than just trying to make your own custom agents.

31:45Now just to add a little bit more context here in terms of how the sub agents work, you can see that there's actually a whole detailed piece of documentation, I'll link it in the description, that goes over this from Anthropic. But you should be aware that when you're doing these sub agents, right, so when you're creating them, they're gonna inherit the tools from the main agent context that they're created within.

32:05So what you can do is you can actually scope specific tools to specific agents. So in this case, you can see tools, read, grab, glop, uh, bash. Right?

32:13You can disallow certain tools, which is a good use of sub agents when you only want them to do something really specific. And then you can also have things like MCP servers directly for one agent. If you have MCP servers that you only wanna use in some context or you don't wanna confuse the agents with too many, then that's another good use of when you would create a sub agent.

32:32There's a lot of cool stuff you could do. You can also scope particular skills, for example. Right?

32:36You can specify the memory that you wanna use with persistent memory, conditional rules, hooks. Like, you can get really, really advanced here. I'm not gonna get into all of that in this video, but I just wanted to show you that if you are gonna go crazy with sub agents, you should read something like this documentation or ask Claude to ingest it for you and give you a summary so you can see, you know, what's possible here in terms of the usage.

32:57What I showed you, just scratching the surface, I just want you to be aware. Again, I rarely find myself creating sub agents, but you can manually if you need to for something really specific like this. Okay.

33:08So moving on, the next concept that I wanna cover is memory. Now first, you need to understand that in ClaudeCode, there is no persistent memory by default.

33:18What that means is that if I go in one ClaudeCode session, I tell it my name is Tim, and then I open a brand new session, Claude code will not know that my name is Tim. It's not gonna remember that. So how do we get around this and understand long term persistent memory in Claude code?

33:33Well, the first thing is just to remember that it doesn't have memory by default, which means anything that you wanna save has to be written down and typically saved in some kind of markdown or documentation file. Now there is a solution that Claude has built into this, which is creating a Claude dot m d file. Let me quickly show you.

33:52Hey. Can you make a Claude dot m d file and just save the my name as Tim? Okay.

33:57So if I do this now and I tell it to make the Claude dot m d file, what it's gonna do is in the local directory here, it's gonna create an all capital Claude dot m d file and it's going to save that. So you can see that Claude dot m d, right, looks like this, project owner named Tim. Now this Claude dot m d file will automatically be read in at the beginning of any new session, so Claude will read any of the persistent data that's inside of that file.

34:21Now you can have this at a project level. You can also have it, as always, at the global level. So you can make multiple Claude dot m d files.

34:29You can have a global one, and then you can have a local one. So now that I've done this, if I exit, right, and I just open up a new Claude session, say, is my name?

34:39Right? Then we should see that it's able to find that this is Tim because it's gonna pull from Claude MD. Right?

34:43You can see there, which is, uh, the persistent long term memory. So anything that you always want to be loaded or you want Claude to just know, you have to put in this Claude dot m d file. This Claude dot m d file exists inside of the dot Claude folder that I showed you previously.

34:59So you have dot Claude and then you have that capital Claude dot m d markdown file there, uh, and all is well. Now that is cool. However, sometimes you wanna store more.

35:09You wanna have more memory, and you don't want it all in one single file. Now that's where creating an intelligent folder structure comes in. It's just something I wanna introduce you to the concept of.

35:18So you guys may have heard of OpenClaw before. If you've heard of OpenClaw, then you understand that this is an AI orchestration platform that effectively uses LLMs in the background to, you know, complete tasks. Right?

35:28Now what they did is they created this workspace directory, and then in the workspace directory, they've created multiple different files that they've instructed the LLMs to read anytime that they load. Now you can do this as well in Claude, and this one quickly showing it to you.

35:43And you notice that we have docs. Right? Documentation.

35:46We have memory where we have all these different memories that are automatically being here. We have different contracts that are being stored. We have skills that have been created.

35:54Right? We have various scripts that we're referencing. We have state.

35:58So as your Claude code project gets a little bit more advanced, you can create a structure like this where you don't just have one Claude dot m d file. You have a whole directory of multiple markdown files, skills, sub agents, whatever it may be, so that you can just get the most out of Claude code.

36:16So really what I'm trying to show you here is that the customization is unlimited. Your work workflow will look completely different than mine, and you need to enhance Claude by adding the skills, adding the sub agents, adding memory, creating persistent information so that it knows what's happening.

36:32Now by default, when you have these markdown files, Claude will typically, if they're named accurately, go in and read them to get additional context.

36:40If it doesn't, you can just directly reference them, so we'll go have a look at it, but that's gonna add a lot of value to your projects. So again, you don't need to copy what I have here, but I'm just showing you that if you wanna create kind of that persistent memory for Clawd, you have to remember it doesn't have memory.

36:54You need to write it down so that it will read from that, and then you can create a structure that's more advanced than just one single file. And in that claud dot m d file, you can even point to various other references so that Claude has a file tree that it can go through.

37:07And this is how you build that memory architecture and how it actually keeps track of what's going on and how if you open it from another computer or you have another session, you don't lose all of that context and information. So that's it, guys. That is gonna wrap up today's video.

37:19I know there was a lot of stuff here, little bit all over the place, but I wanted to show you a ton of different ClaudeCode features that you may not have seen before. I hope that you found this useful. If you did, make sure you leave a like, subscribe, and I will see you in the next one.

The Hook

The bait, then the rug-pull.

Open Claude Code cold and you get a blinking cursor. Open it with skills, MCP servers, and a CLAUDE.md already in place and you get a developer who already knows your project, can push to GitHub without asking, and reviews code in the exact format you want every time. This tutorial closes that gap.

Frameworks

Named ideas worth stealing.

13:41model

Skills as Slash Commands

Any markdown file at .claude/skills/name/SKILL.md auto-registers as /name after session restart. Claude follows the file as standing instructions when the skill is invoked manually or automatically.

Steal forEncode any repeated review, deploy, or test workflow so Claude never needs to be re-prompted for format or structure.

05:12list