16:25Simon Scrapes · Tutorial
I Taught Claude Code to Build You a Personal Brand
A 16-minute live demo showing how three files give Claude enough brand DNA to produce personalized content forever without re-prompting.
June 6thThe argument in one line.
Claude Code's leverage for non-coders comes not from individual commands but from chaining skills, constraining context, and automating repetition — three habits that together turn a general-purpose AI into a system that largely runs itself.
Read if. Skip if.
READ IF YOU ARE…
- You run a business or solo operation and want AI to handle repetitive workflows, not just answer questions.
- You have used chatbots and hit the ceiling where advice ends and real action needs to happen.
- You have CLAUDE.md set up but have not yet built Skills, configured Hooks, or thought about memory management.
- You want to understand the difference between MCP servers and CLI connections before committing to a stack.
- You have experienced Claude stopping mid-task or losing context across sessions and want practical fixes.
SKIP IF…
- You are already comfortable with sub-agents, dynamic workflows, and context rot management — this is the foundation, not the advanced layer.
- You want a code-level deep-dive; the presenter deliberately stays at the concept and demo level throughout.
The full version, fast.
The video draws a clean line between what chatbots do (advise) and what Claude Code does (execute), then walks through 18 numbered concepts that compound on each other. The core thesis is that non-coders underuse three levers: Skills (process documents that teach Claude your standards and chain into single-command systems), context discipline (CLAUDE.md under 200 lines, selective injection, semantic recall via tools like MemSearch), and automation primitives (/goal + /loop + Hooks for self-running tasks). Newer power features — /effort, ultracode dynamic workflows, sub-agents — are covered as situational tools, not defaults. The closing mindset: on a wrong output, reset to a clean checkpoint with /rewind rather than correcting a corrupted context.
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 →Where the time goes.
00:00 – 00:48
01 · Intro / 2026 Update
Framing this as a revised masterclass after more months of daily use; 20% of features, 80% of the value.
00:48 – 01:23
02 · What Claude Code Actually Is
Chatbot vs. execution layer — Claude Code creates files, runs commands, connects tools; chatbots only advise.
01:23 – 02:05
03 · The Terminal Isn't Scary
Terminal is just another input; the desktop app removes even that step. Type claude, treat it like a chat window.
02:05 – 02:37
04 · Better Prompts
Specificity directly governs output quality. Vague in, vague out. Context-rich prompts reduce back-and-forth.
02:37 – 03:55
05 · Permissions & Auto Mode
Default mode prompts for everything. Auto mode (shift+tab) runs a classifier that only blocks genuinely risky actions.
03:55 – 05:06
06 · CLAUDE.md — Tell It Once
A markdown file Claude reads every session. Put rules, preferences, business context here once and never retype them.
05:06 – 08:11
07 · Skills & Skills Systems
Individual skills teach Claude a task to your standard. Chaining skills into a system replaces entire manual processes with one command.
08:11 – 09:40
08 · Connecting Your Tools — MCP vs CLI
MCP bridges Claude to external apps; the full connection stays in context. CLI commands are lighter for infrequently used services.
09:40 – 10:43
09 · Hooks
Zero-token event-triggered scripts in settings.json. Use for mechanical always-do-this tasks instead of asking Claude to remember.
10:43 – 11:43
10 · Show, Don't Tell — Screenshots
Paste a screenshot directly into the terminal. Claude reads images; showing a broken layout is faster than describing it.
11:43 – 13:06
11 · Auto Memory
MEMORY.md stores facts. The three memory jobs are storage, injection, and recall; auto memory handles storage only.
13:06 – 14:38
12 · Injection — The Right Context
CLAUDE.md under 200 lines avoids context rot. Reference external docs selectively so they load only when needed.
14:38 – 16:09
13 · Semantic Recall
Keyword recall fails at scale after months of use. Semantic tools like MemSearch find memories by meaning instead of exact match.
16:09 – 16:51
14 · /Effort and Reasoning
/effort [low|medium|high|xhigh|max|ultracode|auto] allocates thinking tokens to match task complexity.
16:51 – 19:05
15 · Dynamic Workflows (ultracode)
ultracode triggers a mini team: Claude writes the plan, spins sub-agents with clean context, returns only the finished answer. Expensive for complex tasks.
19:05 – 21:10
16 · Sub-Agents vs Skills
Skills are process docs; sub-agents are isolated workers. Use sub-agents when work should be isolated or run in parallel.
21:10 – 23:06
17 · /goal + /loop — Self-Running Tasks
/goal sets a finish-line condition; /loop fires the job on a schedule. Combined they create recurring autonomous tasks.
23:06 – 24:02
18 · The Slot-Machine Discipline
Wrong output? Don't correct — use /rewind to a clean checkpoint and re-prompt with more specificity.
24:02 – 25:01
19 · Stay Portable
CLAUDE.md, skills, MCP servers are becoming industry standard. Design your setup to be portable across AI providers.
Lines worth screenshotting.
- Claude Code is an execution layer, not a thinking layer — it creates files, connects tools, and runs commands; chatbots only advise.
- The terminal is just another input window; the Claude Code desktop app removes even that barrier for non-coders.
- Prompt specificity is the single biggest lever on output quality: vague instructions produce vague results by design.
- Auto mode runs a background classifier that only stops for genuinely risky actions — switching it on immediately removes approval fatigue.
- CLAUDE.md is a permanent system prompt; write your rules, preferences, and business context once and stop retyping them.
- The real leverage in Skills is not the individual skill — it is chaining three skills into one command that replaces an entire manual process.
- MCP connections load their full tool registry into context for the whole session; use CLI commands for tools you access rarely to protect working memory.
- Hooks run zero-token automation at set events; use them for mechanical 'every time X, do Y' tasks instead of asking Claude to remember.
- Pasting a screenshot directly into the terminal is faster and more accurate than describing a broken layout in words.
- Auto memory handles storage only; injection and recall — the harder two jobs — require deliberate CLAUDE.md discipline and external tools.
- Keeping CLAUDE.md under 200 lines is not a style preference; beyond that, context rot actively degrades session performance.
- Keyword-based recall fails after months of use at scale — semantic recall tools like MemSearch are the practical production fix.
- /effort allocates more thinking tokens to a task; the tradeoff is real (more time, more cost) so match effort to actual complexity.
- ultracode triggers a dynamic workflow: Claude writes its own plan, spins specialist sub-agents with clean slates, and returns only the finished answer.
- A sub-agent is not a skill — skills are process documents; sub-agents are isolated workers who report back only their results.
- /goal + /loop combined: /loop fires the job on a schedule, /goal defines done — together they create a task that runs itself until complete.
- Correcting a wrong output compounds the error by bloating context with broken code; resetting to a clean checkpoint with /rewind consistently works better.
- Every concept here — CLAUDE.md, skills, MCP servers — is becoming an industry standard and works across providers, not just Claude Code.
Eighteen rules that let non-coders own Claude Code.
WHAT TO LEARN
Claude Code is not a better chatbot — it is an execution layer that actually changes files, connects tools, and runs tasks, and non-coders access most of its leverage through four compounding habits.
01Intro / 2026 Update
- The first version of this video was one of the most-watched on the channel; the update reflects months more of daily production use and includes features that did not exist before.
02What Claude Code Actually Is
- The distinction between a thinking layer (chatbot) and an execution layer (Claude Code) is the single most clarifying mental model for deciding when to use which tool.
03The Terminal Isn't Scary
- The terminal is just another input window; the Claude Code desktop app removes even that barrier, so non-coders can access the full tool without ever opening a terminal.
04Better Prompts
- Specificity is the only lever directly under the user's control in every prompt — vague instructions reliably produce vague outputs, and more upfront detail reduces back-and-forth.
05Permissions & Auto Mode
- Auto mode removes the approval-fatigue that kills beginners — a background classifier handles risky-vs-routine without you reviewing every action.
- Switch to auto mode at the start, not after you have already been frustrated by endless permission prompts.
06CLAUDE.md — Tell It Once
- CLAUDE.md is a permanent system prompt: put your rules, preferences, and business context there once and stop retyping them into every session.
07Skills & Skills Systems
- Individual skills are useful; skill systems are the actual leverage — chain three skills into one command and replace a multi-step manual process entirely.
- The output of one skill becomes the input of the next, so complex multi-stage workflows can be triggered with a single natural-language request.
08Connecting Your Tools — MCP vs CLI
- MCP connections load their full tool registry into context for the whole session; use CLI commands for rarely-used services to protect working memory from context rot.
- Connecting too many MCP servers silently degrades Claude's performance by filling the context window with unused tool definitions.
09Hooks
- Hooks handle mechanical always-do-this triggers at zero token cost; anything that follows a simple event rule belongs in a Hook, not in Claude's memory.
10Show, Don't Tell — Screenshots
- Pasting a screenshot directly into the terminal is faster and more accurate than describing a broken layout in words — Claude reads images natively.
11Auto Memory
- Auto memory handles storage only — injection (CLAUDE.md under 200 lines) and recall (semantic tools like MemSearch) are the harder two jobs and need separate attention.
12Injection — The Right Context
- Context rot is real and measurable: as Claude's working memory fills, performance degrades, which is why CLAUDE.md should stay under 200 lines and reference external docs selectively.
- Selective injection — pointing to an external doc in CLAUDE.md rather than including its content inline — lets Claude load and offload context only when it is actually needed.
13Semantic Recall
- Keyword-based recall fails after months of heavy use — semantic search finds memories by meaning, not by matching the exact words used at the time of the original conversation.
- Open-source tools like MemSearch solve the recall problem without waiting for the built-in system to catch up.
14/Effort and Reasoning
- /effort is a deliberate dial: higher effort costs more tokens and takes longer, so matching the effort level to the actual complexity of the task is itself a skill worth developing.
15Dynamic Workflows (ultracode)
- ultracode (dynamic workflows) solves three recurring problems at once — premature stopping, self-bias in self-review, and context rot on long tasks — by giving each sub-agent a clean slate.
- This is a power tool for complex or research-heavy tasks, not a default setting — the token cost is significant.
16Sub-Agents vs Skills
- Sub-agents and skills are not the same: skills are process documents any agent can follow; sub-agents are isolated workers who return only finished results to protect the main context.
- Use a sub-agent when the work would pollute the main context window, could run in parallel, or produces output that the main flow only needs as a finished artifact.
17/goal + /loop — Self-Running Tasks
- /goal + /loop combined creates a task that runs itself on a schedule and will not stop until the defined finish-line condition is met.
- The three-day interval expiry on /loop means this pattern is best suited for daily or weekly recurring tasks, not long-running multi-day operations.
18The Slot-Machine Discipline
- The slot-machine principle is a concrete debugging rule: when the output is wrong, do not ask Claude to correct it in place — use /rewind, return to a clean checkpoint, and re-prompt with more specificity.
19Stay Portable
- Every concept in this video — CLAUDE.md, skills, MCP servers — is already becoming an industry standard, which means the investment in learning them is portable across any AI coding tool.
- The same setup transfers to other providers with minor renaming (e.g., CLAUDE.md becomes AGENTS.md elsewhere); design for portability from the start.
Terms worth knowing.
- CLAUDE.md
- A markdown file Claude reads at the start of every session, functioning as a permanent system prompt. It stores rules, preferences, and business context so they do not need to be retyped into each conversation.
- Skill (Claude Code)
- A prewritten process document, stored as skill.md, that teaches Claude how to complete a specific task to a defined standard. Skills can be chained together so the output of one feeds the next.
- Skill system
- Two or more skills wired together so a single user command triggers an end-to-end process — e.g., picking a topic, writing copy in a brand voice, and generating a carousel layout in one shot.
- MCP (Model Context Protocol)
- A bridge that connects Claude Code to external apps like Notion or Google Drive, letting it read and take actions inside those tools. The full connection stays loaded in context for the whole session.
- CLI connection
- An alternative to MCP for rarely-used tools: Claude runs a single command to that service only when needed, avoiding the context-window cost of a full MCP session load.
- Hook
- A small script wired to settings.json that fires automatically at a specified event (e.g., every file save) without consuming AI tokens, useful for mechanical always-do-this triggers.
- Context rot
- Gradual performance degradation that occurs as Claude's working memory fills up — loaded context competes for attention, causing earlier information to be forgotten or ignored.
- Injection
- The subset of memory management that determines what context is loaded into Claude's brain at the start of a session before the user types anything. CLAUDE.md is the primary injection mechanism.
- Semantic recall
- Finding stored memories by meaning rather than by matching exact keywords. Required for reliable long-term retrieval as the volume of saved notes grows; open-source tools like MemSearch implement this.
- /effort
- A Claude Code slash command that sets the reasoning effort level for a task, from low to max/ultracode. Higher effort allocates more tokens to thinking, improving output quality at the cost of time and token spend.
- ultracode / Dynamic Workflow
- A Claude Code keyword that triggers a dynamic multi-agent workflow: Claude writes its own plan, spawns specialist sub-agents with isolated context, and returns only the finished result. Expensive; suited for complex or research-heavy tasks.
- Sub-agent
- An isolated instance of Claude that handles a clearly bounded task in its own context window and returns only the finished output to the main conversation, preventing context pollution.
- /goal
- A slash command that sets a finish-line condition Claude must verify before stopping, preventing premature task termination.
- /loop
- A slash command that schedules a prompt or slash command to fire automatically on a recurring interval (up to every three days).
- Slot machine principle
- A mindset rule from the Claude team: when an output is wrong, return to a clean checkpoint with /rewind and re-prompt with more specificity rather than asking Claude to correct the flawed output in place.
Things they pointed at.
15:18toolMemSearch
23:30tool/rewind
Lines you could clip.
01:10
“ChatGPT is a thinking layer, but Claude code is an execution layer.”
03:58
“If you take one thing away from this video, let it be that context is so incredibly important.”
06:36
“The real leverage doesn't come from individual skills. It comes from chaining a few of them together into a system.”
10:22
“It's actually just a waste of tokens asking AI to do something that's so mechanical.”
13:20
“When you break down memory, it's three jobs. Storage, injection, and recall.”
15:05
“You could ask it about a pricing decision that you made six months ago and it will literally find nothing.”
23:10
“Treat Claude code like a slot machine. If it doesn't give you the output that you want, don't ask it to go back and correct that.”
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.
metaphoranalogy
00:00Clock code might just be the most powerful tool that you can put in front of a business right now. But if you don't have a coding background, it also looks very intimidating. It's got a black screen, confusing terminology, and tutorials that assume you already know things that you don't.
00:13So this is the complete guide for people who don't code. And if you saw my first version of this video, the one a lot of you watched, this isn't a rerun. After several more months working daily inside the tool, I teach a good chunk of it differently now.
00:25There's a bunch of new stuff that didn't exist back then too, and I've reordered the whole thing around what actually matters. And if you've never touched code, you're in exactly the right place. There are dozens of features inside Clor code, but a handful do most of the work.
00:37So I'm gonna give you the 20% of Clor code that gets you 80% of the value. We'll move fast through the basics, then spend the real time on what matters most. Right.
00:45Concept one then. So most of you already know chatbots. Think Chattypete, Claude, Gemini.
00:51You type a message, you get a reply, and that's useful, but it's the ceiling of what chatbots do. They offer advice but can't take actions. They So can't reach into your computer and actually make something happen.
01:01So you end up as the middleman still copying their answer out, pasting it somewhere, and ultimately actually doing the actual work yourself. Claude code is designed to remove that step. It can create files, connect to tools like your CRM, build your website, set up a spreadsheet, run your repetitive tasks, all from a similar chat window.
01:18So think about it a little bit like this. ChatGPT is a thinking layer, but Claude code is an execution layer. So now that you know what it is, here's the bit that scares most people off.
01:26Claude code is often seen running inside a terminal. That black screen with the white text that you've watched your developers use, and it looks like you need to be one of them to get the most out of it. But in reality, you don't.
01:36The terminal is just another way to talk to your computer. And when you're using Claude code, you barely interact with it directly. So you might be working inside a terminal view.
01:44But once you type in Claude to open the app, then you treat it just like a chat window. Besides, you can now just run it inside a nice UI like the desktop app anyway. You don't even need to type Claudine to open it.
01:54So once you're inside, you can think of it as the same as ChatGPT, but now it can take actions, it can connect your tools, and it can create files, most importantly, on your behalf. So what do you actually say to it?
02:05This brings us to prompts. And a prompt is just what you type to tell Claude what to do exactly like you did inside Chateaubiti. So there's nothing new to learn here, but there is one habit worth building from the start.
02:16The quality of what you get back is tied to directly how specific you are. How you give vague instructions in and you'll get vague outputs out. The more detail you can give it up front, the less back and forth you're gonna do later.
02:27It's exactly like embedding specific examples inside the prompts when we type into a chat window. But because it's able to access our files, it brings us to the first thing that's different from ChatGPT here, which is permissions and auto mode.
02:39So because CallCode can actually make real changes to your machine, it can create files, run commands, even delete files, We should know about how to give it permission and when not to, when to actually deny it. And at the start, you'll want to run it in its default mode where we'll ask you for permission for pretty much everything.
02:54But a lot of it kinda just looks like jargon anyway, to be honest. You don't even know half the time what you're approving because it looks so technical. So you end up clicking approve every ten seconds on a simple task that you've asked it to go and do.
03:04And it really does start killing your flow and has you questioning why you ever decided to try call code in the first place. But luckily, Anthropic have seen this and they understand that nontechnical users need some guardrails, need some automated guardrails.
03:16So it needs to stop the things that are genuinely risky, like deleting your files and ask you for permission there, but then approve the stuff that's pretty mundane, pretty routine, and doesn't actually need to be questioned. The stuff you don't wanna be seeing. And that brings us to auto mode.
03:29And you can switch on by hitting shift tab to cycle through the different modes, and you can see auto mode on. Now in the background, it's running a classifier that checks each action for you and only stops to ask you when something, like we said, is genuinely risky.
03:42So Claude just gets on with the work, and you only get pulled in for the decisions that actually matter, like deleting files or connecting to new systems, connecting to stuff outside of your file base. As So soon as you're starting in ClawCode, I'd highly recommend just switching auto mode on and starting from there. Now context is so incredibly important.
03:58And if you take one thing away from this video, let it be that. When we give a prompt, are supplying context to the model.
04:04We talked about how good examples help us achieve good outputs when we're using that model. Now there's a file that Claude reads at the start of every single session, and you can treat this like a system prompt, and it's called Claude dot m d. And the dot m d just means it's a markdown file.
04:17So it's something that's human and AI readable. It's very easy to read, but AI is also familiar with markdown format. And inside that Claude dot m d, we're gonna put our rules, our preferences, how our business works inside that file.
04:28And we're only gonna do it once, then it's gonna follow them forever. So think about all that context that you would always add inside a prompt inside ChatGPT, and we're just putting it into a file so we don't ever need to type it again and again. So those first five we've just covered are the foundations.
04:42So you now know what Clog code is, how to talk to it, how to keep it safe through auto mode, and how to make it yours through a personalized Claude dot m d file. Now let's help you get the most out of it. Now if you spent much time on chat interfaces, you'll understand the concept of projects.
04:56So like our Claude dot m d file, you save some context into a project folder, and you ask the chat to read it before it answers your question. So we're supplying context to answer that question. And a skill is the same idea, but for a task instead of a topic.
05:11Because here's the thing, Claude code is a generalist out of the box. So it'll do most things to a pretty good standard, with recent models.
05:18It will do things to a good standard. But for the specific tasks that you do over and over in your everyday life, it won't produce the same quality as you do. And the simple reason for that is it's lacking your context.
05:28So we need to show it how to do it as well as you do, and that's where skills come in. So skill is a set of prewritten instructions that teach Claude how to do your task really, really well.
05:37So instead of reexplaining what good looks like every single time, Claude is gonna read the skill first and do it your way. So it's a step by step guide with a clear description of when it should actually be used so that Claude can go and find and work out when to use that skill. So say for example, something we all need is a skill that copyrights in our brand voice.
05:55It has a set of step by step instructions on how to emulate exactly how I sound and who I target. But this is the point where most people stop too early. The real leverage doesn't come from individual skills.
06:05It comes from chaining a few of them together into a system. So treating them like modular building blocks where the output of one becomes the input of the next, and then you can run the whole thing with a single command. And that will replace an entire process that you do manually right now because you've written a context that goes in the step by step instructions.
06:21So let's just make that real with one I've started using every single week. So say I wanted to turn an idea into an Instagram carousel on its own, that's three separate jobs. Number one, we've got pick the topic where you actually wanna talk about.
06:33Secondly, we've got write a copy in my voice. And third, we've got to lay it out as a nicely designed carousel using my visual styles, my color palette, my fonts, etcetera. So we've got three steps, and independently, those could be three different skills.
06:45But a skill system actually change those into a single end to end process, chaining multiple skills together. And that's exactly how skills are designed to be built and connected together. So think of them like a prompt that's stored in a file called skill dot m d.
06:58I just tell Claude that I want a carousel. It reads all my skill descriptions, picks the right skill, and produces from start to finish a set of carousel slides.
07:06So you can quite literally go through all of your manual processes, break them up into individual steps, and turn those steps into skills that can be used again and again by Claude. And they'll be able to, with your context, achieve the same level of quality but possibly improved consistency over you doing the task yourself.
07:22And you can start small here. Pick one process that you do most often inside your business and have a working prototype in a few hours. It's quite literally incredible.
07:31Now everything so far has been working with just files on our computer, those dot markdown files. But more often than not, you're working with your calendar, your CRM, your Notion, and a dozen of other tools inside your business.
07:43So let's talk about how to connect Claw to those tools so it can take actions directly in the tools and apps that you work with. Now before we do that, if you've learned anything so far, then you might benefit from joining our paid community, which takes you all the way through setting up Claw code from Xero and helps you to take your individual business processes and turn them into these modular skill systems piece by piece so that you can augment the work that you or your team do every single day and ultimately get back your time.
08:07So if you're interested in that, check it out at school.com/scrapes or the links below in the description. But like we said, everything so far happens with files on your computer, but mostly that's not where we're actually working.
08:17So it brings us to the concept of MCP, which stands for model context protocol. And you can think of this as the bridge between AI tools like Claude code and our day to day tools like Google Drive.
08:27So it can do everything that Claude can. So it can read as well as take actions quite literally in your apps. And all we need to do to set it up is actually tell Claude connect to the Notion MCP, and it will go out and find the docs.
08:38'll create the connection on your behalf, and then it just asks you to authenticate using your Notion API key, for example, which it will direct you to find too. So it does every single part of that step for you, and you've got an MCP connection that's connected directly into the tools you use every day. But the thing that people miss when they're setting these up at first and the thing you need to know is that an MCP connection stays loaded the whole session.
08:58And what we mean by an MCP connection is that it loads in all the tools it has access to and instructions on how to access those tools. So connecting loads of them quietly, Notion, Google Drive to your CRM, that context of how to connect to those tools and what tools are available will be sat in your context window, which will quietly eat into Claude's working memory.
09:16So a word of warning is that if it's a tool that you don't use often, maybe a command here or there or an API, then there's a popular alternative called the command line interface connections where at the required time, ClaudeCode would just run a single command to that service so you don't have all of that data stored inside your context.
09:31This, of course, will reduce the token usage and therefore your cost. And whilst we're on the concept of AI tokens, every time you use a single token, it's gonna cost you more. So most setups are monthly subscriptions where you have a token limit.
09:43So you're not gonna go overboard. You have a daily limit, a weekly limit, and a monthly limit. And it's gonna cost you around $20 a month for the pro plan for ClawCode at the time of filming.
09:51But there are some things where just because you're using an AI tool like ClawCode, it doesn't mean you need to use AI for absolutely everything. So if it's an if this, then that kind of scenario, then we can actually just use hooks instead.
10:02So it's for things we want to run every single time with no thinking required. And it also solves a problem we'll come to later of AI forgetting to do things, which actually does happen more often than you think. So if it's a task that's absolutely required at a certain event, then we use hooks.
10:16So they're a small script that fires at a set moment. And here's a simple example of one that you might actually use. So every time Claude saves a file, I want it formatted consistently.
10:25I could ask Claude to remember to do that like inside our Claude dot m d document. It's actually just a waste of tokens asking AI to do something that's so mechanical. Every time this happens, do this thing.
10:35Every time you save a file, format that file in a certain way. So instead, I can actually just set a hook. When a file gets saved, run a formatter script, and that's it.
10:43To set this up, I just need to ask CoreCode to build the hook for me, and it's just added into a settings dot JSON file, which is read in each session I'm in. So it knows to invoke that hook every time it saves a file. Now this next one is a quick hack.
10:56Now that you started working inside your tools, it's sometimes easy to show the problem rather than describe the problem. So it's gonna save you a lot of time. Instead of describing every problem that you want to fix, just screenshot, copy and paste into the terminal directly, and ClaudeCode actually can read your images.
11:10So if you're building out a website and there's a broken layout with an overlap, then you can take a screenshot and say, fix this, and it will be able to determine exactly what you mean. It will be able to look at the screenshot, analyze it, and work out there's an overlap in the layout there. Now with all these tips, you're able to get the most out of ClawCode in the shortest space of time.
11:27There's still one major limitation of ClawCode out the box as it is today, and this deserved its entire own section. And it's all about how ClawCode stores things you tell it and recalls things that you tell it, both short term and long term. Because as you start using Claude over multiple sessions, you want it to be building up an understanding of how you work, what projects you work on, and your business so it gets better over time.
11:49So it's basically a cycle of you working with Claude more and it continuing to get better and faster as you work with it. So Anthropic recognized this and built in an auto memory function which saves a specific memory dot m d file of your projects and your preferences.
12:04So you can literally ask it to remember a fact and it will store it in that memory file. But ultimately, that memory dot m d file is just a table of facts that points to a series of different files which contain specific details of memories of our projects or groups of things you like to talk about a lot with crawled code.
12:19So . Now here comes the caveat though. It's not very good especially for large amounts of data.
12:26And don't get me wrong, Anthropic has been working on this, but it's still a very complex problem. And the open source community is kind of leading the charge on best practice at the moment. So when you, like, break down memory, it's three jobs.
12:37It's storage, which is what gets saved. Injection, I e, what loads back in at the start of every conversation, like our claw dot m d file.
12:45And recall, pulling the right bit of info when it's needed and only when it's needed without overloading Claude's memory by pushing in all the information at once. Now auto memory is designed to handle that first job of storage and it's predominantly the other two injection and recall where Claude code really falls down and where the better options actually come in.
13:04So let's cover them one at a time. So injection. This is what gets loaded into Claude's brain at the start of a session before you said anything.
13:12So your Claude. M d is a good example of injection. So one, it's important that our Claude .md is kept concise.
13:18And by concise, mean highly recommended under 200 lines because as Claude's working memory grows, performance is known to degrade. So this is called context rot.
13:27As we load more context in, context starts getting forgotten. And two, because we're keeping Claude .md concise here, the other rule is that we can reference other context to load it in selectively. So for example, Claude .md can just say, actually, if you need anything with a brand voice, you can reference this brand voice dot m d document from this location in the folders.
13:47And then Claude can decide to load that in only if it's needed. And more importantly, it can offload it when it's not needed. So it's not loaded into the conversation every single time wasting tokens and causing Claude to forget context.
13:59And we could get into the details of other memory files that you can automatically inject into Claude's brain like a soul or short term memory injection that focuses on recent information. But when you're just starting out, it's best to just keep your Claude dot n d concise and keep any reference context in those separate documents that are pointed to by the Claude dot m d.
14:16So fundamentally, it brings us back to the fact it's about loading in the right context at the right time, which brings us to long term context to memories. Now imagine you're a business owner. You have employees.
14:26You have departments. Or it might just be yourself with lots of client conversations. But there's a lot of context that we want to just recall only when it's necessary.
14:35So we want it to be recalled correctly as well, which is the third job. So recall is as it sounds, it's pulling a memory back later on when you actually ask for it. So out of the box, ClawCode finds old memories by trying to match keywords that you've asked it for.
14:48So it's basically searching for the exact words you used in previous conversations. And bear in mind, a lot of our conversations get compacted, and therefore we lose a lot of the detail inside Grail code.
14:58So effectively works fine for a few dozen notes or shorter conversations, but months later, it sucks to be honest.
15:04Like, you could ask it about pricing decision that you made six months ago and it will literally find nothing because that wasn't the exact set of keywords that you used at the time or it's compressed the conversation. Now semantic recall is supposed to fix that because instead of searching by keywords, it searches by meaning.
15:20So the point I'm getting to here is you can actually improve Claude's recall by using open source tools like MemSearch, for example, that help store and find the right notes so that when you use Claude code long term, even with huge amounts of data, you can still recall information about decisions you made as one example.
15:35Now I've got a separate video going through lots of different memory systems on my channel you're interested in diving into that section in more detail. But now let's talk about some of the recent improvements that have massively improved the quality of outputs that you can get inside ClawCode. So in a world of a thousand updates in the last quarter, it's important to just pick out the only ones that I've seen that actually matter to you.
15:55And before we do that, if you are getting value from this video, then do me a favor and hit the subscribe button below because YouTube tells me that most of you watching aren't actually subscribed, and it genuinely helps me keep making these videos. Now the first of the newer concept is slash effort. And it's all about turning up Claude's effort level.
16:13And I know this sounds silly because you're probably thinking, like, why wouldn't you just ask it to put in high effort all the time? But there's naturally quite a compromise when you do that. It takes more tokens, which costs you more, and it's gonna take longer.
16:24So for complex tasks, just wanna type in slash effort, and you can pick between the options of low all the way through to max, ultra code, or even just automatically choose. And what we're trying to do is match the effort level to the thinking required in that task. So it's all about reasoning.
16:38So it just means that Claude allocates more tokens towards thinking and reasoning so that you get genuinely better outputs or genuinely more thought out outputs. And it links so closely to this next topic, and you can see it here, UltraCode. So up until now, Claude has planned and executed in one single conversation, all in front of your eyes, and on a big job, a longer conversation.
16:59That's gonna break down in one of three ways. If you've used Claude code for any amount of time, you'll notice they often stops early on a task and basically says it's done when it's not done, which is incredibly frustrating. It also tends to trust its own work too much.
17:11So it biases to say that it's done a good job when you ask it to check its own work. And then thirdly, it slowly loses sight of the original goal as the conversation and context loaded in gets longer. So this is the context rot that we mentioned a couple of times now.
17:24Now dynamic workflows that spawn off this keyword ultra code, you can see dynamic workflow requested for this turn, is designed to fix all three of those issues. So it's like a little worker where Claude writes up his own plan for the task. It spins up a little team of agents if that's necessary and gives each one a clean slate and a clear single job.
17:43They then are able to check each other's work and hand you back just the finished answer. So think of it like a a mini team and a plan that Claude is gonna write up with its max amount of thinking tokens that you can spin up by just adding your prompt after the word ultra code. And like the max effort that we saw before, this uses an incredible amount of context and tokens, an incredible in a bad way.
18:04So I'd only recommend either using this to try it out or for a task that requires a great deal of thinking or deep research. And this is exactly how Clawcodes built in deep research function works under the hood. It spawns this deep research harness that goes out and conducts research in a certain way.
18:21And the way this Ultracode work or dynamic workflows work under the hood is actually to determine a set of steps that need to be taken and then break it out into individual sub agents and a series of steps. Now there are six commonly used formations, but these aren't the only ones. But at a surface level, can consider that Claude has taken upon itself to manage your task closely and thoroughly by breaking out individual steps into one of these workflow patterns.
18:42So for example, deep research, I believe uses the fan out and synthesize. So we have an initial task. It goes and does individual series of research in different locations and then synthesizes that result into a report at the end.
18:54That is one of those workflow patterns. It means Claude code is starting to push the boundary on not having to actually create the team yourself, just giving Claude an end goal and seeing how close it can actually end up to that goal or output.
19:05Now there we mentioned that it spins out sub agents and sub agents and skills often get confused. But this is how I think about them personally and hopefully this helps a little bit with your thinking process. So skill as you know is a process document telling Claude how to do something properly.
19:18A sub agent is who's doing the work and it's often off in its own isolated space reporting back with just the finished job once it's done. So when you're working inside the Claude screen or the terminal, you're already working with an agent. It's an instance of an agent or a sub agent.
19:32And that agent can use skills. You sometimes might find yourself reaching for another sub agent because you don't want to pollute the context of your main conversation window. So all links back to that context rock problem that we mentioned earlier.
19:43So sub agents are used because they can actually go out and do a really defined task and they can use skill documents that actually do that task. So that might be a little bit confusing.
19:51So let me show you exactly where the line sits using our own Instagram carousel system that we showed earlier because it actually uses both skills and sub agents in conjunction. So most of that system is actually just skills chained together. There's no separate worker.
20:03It's an instruction guide in a skill file it's and gonna run step by step in the main window. But then it gets to the image generation step, and that step is messy. It's basically loading a heavy set of style references from my visual references, and it also runs scripts into the image models like GPT or Nano Banana Pro.
20:21So it's gonna load a lot of noise and code that will pollute that main context window. Our conversation in that main context window should be preserved. And the way that we do that is we hand off to a sub agent.
20:31It has its own set of individual context and only brings back the finished result to our main context window. So we've got complete context isolation. And then secondly, we've got separation of concerns.
20:40So the main flow just asked for an image. The sub agent goes and gets the image using its own context and basically delivers back that image. It doesn't need to know how it was made, which script ran, which model was used to get the image.
20:51It just needs the image as an output to put into the carousels. So the general rule of thumb I use is keep it as a skill when the work is tied to what you're already doing in that context window and you'll want the results in front of you.
21:02But reach for a sub agent instead when the work is actually completely separate or could be isolated, or you want to run several at once in parallel. Now earlier, mentioned some limitations in Cycloak Code. The Claude basically does a lot of a task sometimes but stops in the middle of a task.
21:17So Claude Code has built some really important concepts that help with this called slash goal and slash loop. And they're at their best when they're paired together. So slash goal, set a goal that Claude checks before stopping.
21:29We basically put in a condition here giving Claude a finish line that it has to actually reach before it's allowed to stop that process. So it has a small checker confirming after each term whether it's actually achieved the goals. So it's like a worker that never stops until it's reached our definition of what done looks like.
21:44Now you can imagine that racks up the tokens if you're not clear enough on the definition of what done looks like or if it's not measurable. And then slash loop, run a prompt or slash command on a recurring interval, e g a loop of five minutes or daily. Basically, asks us to set up an interval and then give it a prompt to run on that interval.
21:59So it's doing a different thing slash goal. It's making a job a repeat job on a schedule instead of being able to run that once. So it's the same prompt that we can fire automatically, say, every Monday morning without you starting yet.
22:11So you compare loop and goal and add a single instruction to become a task that runs itself on a cadence and won't quit each time until it reaches that goal or until the outcome condition is actually met. Let's just make that real with an example. Every Monday, you check what your competitors shipped that week.
22:27Now with these two conditions, you just set it once. So slash loop is gonna fire the job every Monday at 9AM, and slash goal tells it what done looks like. So every competitor website on the list is gonna be checked, It's gonna be scraped, and a short summary is gonna be written up for each competitor.
22:42So it's gonna be able to run itself, and it won't stop on a Monday until all of those competitors are actually checked through. Now there is one slight caveat to slash loop. At the moment, it has an interval expiry of every three days.
22:52So you can only use it on tasks that are shorter than three days, but it's still a really powerful combo to use together. So now you know how to get the most out of Clog code. Let's finish on some mindset shifts you need to make to use these tools more successfully.
23:05And the first is called the slot machine principle. So here's the trap that almost everyone falls into, and I do this all the time. You're in a conversation with Claude and it makes a wrong turn.
23:13It makes a bad edit or it misreads your instruction or you weren't specific enough. And your instinct then is to go back and correct it. So you type, no.
23:20That wasn't quite right. Can you fix this thing? And now it's working from broken code plus the new set of context and the old code acts as a correction inside of that context.
23:29So it starts bloating the memory of Claude. So a tip to handle this directly from Anthropix team themselves is phrase like this, . If it doesn't give you the output that you want, don't ask it to go back and correct that.
23:42Go back to a clean checkpoint. You can use the slash rewind feature for this and then re prompt it again with more specific instructions. So quite frankly, it goes against our very nature of trying to rework something that's broken to just scrapping what's been done and trying again.
23:56And that one's definitely easier said than done. You'll find yourself trying to correct things, and then you will remember this tip and use the rewind feature. And then finally, remember that all of the fundamentals you've learned today travel across other providers.
24:08So we've talked a lot about ClawCode, but the conventions and the limitations all exist across platforms.
24:14So most of it like skills, your instruction in the dot MD files, your tool connections in your MCP servers, and the like are all industry standard or becoming industry standard. So you're able to port over to any tool at any time. And, of course, there are some simple differences like the Claude dot m d is actually called agents.md elsewhere, but it's important to understand that you don't want to suffer at any point from vendor lock in.
24:37So take these learnings and always think about how your setup is going to stay portable. So with that last one, you've now got a complete picture. You know what Claude code is and why you'd use it over a chatbot.
24:48You've 've got the foundations. You know some tricks on how to get the most out of it, and you've got a sense of what makes up a real and usable memory system and how to run it more autonomously. So make sure to check out our community in the description if you enjoyed this one.
25:00See you in the next
The Hook
The bait, then the rug-pull.
The most powerful tool for your business is also the most intimidating — a black screen, cryptic terminology, and tutorials that assume you already know things you don't. This masterclass cuts through all of it: 18 concepts, plain English, 25 minutes, built from months of daily use after the first version of this video hit.
Named ideas worth stealing.
01:10concept
Thinking Layer vs. Execution Layer
Chatbots give advice but cannot act. Claude Code is the execution layer that creates files, connects tools, and runs commands on your behalf.
Steal forpositioning AI tools to non-technical clients
00:30concept
20/80 Claude Code Rule
Dozens of features exist but a handful deliver most of the value. The masterclass covers only the 20% that gets 80% of results.
Steal forany product tutorial that wants to reduce overwhelm for beginners
12:30list
Three Memory Jobs: Storage / Injection / Recall
- Storage — what gets saved (auto memory handles this)
- Injection — what loads into context at session start (CLAUDE.md)
- Recall — pulling the right memory when needed (requires semantic tools)
Auto memory handles storage. CLAUDE.md handles injection (keep it under 200 lines). Recall at scale requires open-source semantic tools like MemSearch.
Steal forany system that involves persistent AI memory
06:00model
Skill Chaining System
Individual skills → connected skill chain → single command replaces multi-step manual process. The output of one skill becomes the input of the next.
Steal forany workflow automation pitch, content production pipelines
23:10concept
The Slot Machine Principle
When Claude gives a wrong output, do not try to correct it in place — that bloats context with broken code. Pull the handle again: use /rewind, return to a clean checkpoint, re-prompt with more specificity.
Steal forAI debugging mindset, prompt engineering advice
21:00model
Skill vs. Sub-Agent Decision Rule
Keep it as a skill when the work is tied to what you are doing in the current context window and you want results in front of you. Reach for a sub-agent when the work is isolated, could be parallelized, or would pollute the main context.
Steal formulti-agent system design, workflow architecture decisions
How they asked for the click.
VERBAL ASK
07:55product
“if you've learned anything so far, then you might benefit from joining our paid community, which takes you all the way through setting up Claude code from zero”
Placed at the 8-minute mark mid-video, brief and returns to content immediately. Second soft sub-ask at 16:00. Community link again in closing at 24:55.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
