Big Idea

The argument in one line.

The gap between users who run their entire business through Claude Code and those who treat it as a chatbot comes down entirely to 14 specific setup decisions, not prompting ability or coding skill.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code daily but still manually approve most actions and get pulled back to your desk constantly.
You want Claude Code to run scheduled tasks autonomously and stay reachable from your phone when your laptop is off.
You build skills but have not yet structured them as interoperable modular systems that share components.
You have connected multiple MCP servers and suspect they are burning tokens before any work begins.
You want a concrete decision rule for when to reach for a sub-agent versus a skill.

SKIP IF…

You have never used Claude Code and want a beginner orientation — this assumes working familiarity with the tool.
You are looking for prompt-writing, copywriting, or creative AI tips rather than agentic infrastructure setup.

TL;DR

The full version, fast.

Most Claude Code users are stuck with 2025 habits — approving every permission, fighting broken sessions with more context, running single-window tasks. Fourteen setup decisions fix all of that: UltraCode lets Claude design its own multi-agent workflow; auto mode replaces dangerous permission skipping with a classifier; /loop and /goal chain into autonomous recurring tasks; modular skill systems treat individual skills as Lego blocks shared across pipelines; CLI tools cost zero tokens when idle while MCPs do not; semantic memory frameworks like MemSearch restore past context by meaning rather than keyword; and a VPS plus tmux plus Telegram keeps Claude working around the clock from any device.

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:43

01 · Intro: the setup-decisions gap

Frames the divide: chatbot users vs business-runners. The gap is architectural, not skill-based.

00:43 – 05:40

02 · #1 Dynamic Workflows / UltraCode

Claude writes its own multi-agent harness. Six workflow patterns from Anthropic docs. Live demo: 26 agents, 670K tokens, 13 minutes.

05:40 – 06:27

03 · #2 Auto mode

Replaces dangerously-skip-permissions with a classifier. Shift+Tab twice.

06:27 – 09:14

04 · #3 Autonomous long-running tasks

/loop on a cadence + /goal with a stop condition. Gmail triage demo: 1 turn, 2003 tokens.

09:14 – 10:53

05 · #4 Skills, built the right way

Under 200 lines, progressive disclosure, self-learning rule section.

10:53 – 13:20

06 · #5 Skill systems

18-skill social-content pipeline as Lego blocks. Shared skills maintained in one place, reused across multiple systems.

13:20 – 15:09

07 · #6 MCP vs CLI

MCP loads definitions permanently; CLI costs nothing until called.

15:09 – 17:25

08 · #7 Memory power-ups

Semantic search (MemSearch, Hermes) vs keyword-only built-in recall. Three-layer model: storage, injection, retrieval.

17:25 – 18:52

09 · #8 Folder structure / Agentic OS

CLAUDE.md instructs which context folders load for which jobs.

18:52 – 20:34

10 · #9 Planning the right way

Plan mode default folder is disposable. Fix: write the plan into project files.

20:34 – 22:11

11 · #10 Rewind, don't argue (Slot Machine Theory)

Correcting a broken session adds broken code plus failure context back in. /rewind rolls back to any checkpoint.

22:11 – 22:47

12 · #11 Multi-Clauding / Agent View

claude agents dashboard groups by repo and status.

22:47 – 23:54

13 · #12 Escape routes

agents.md, SKILL.md, MCP/CLI are open standards. CLAUDE.md is a renamed agents.md.

23:54 – 25:49

14 · #13 From anywhere, 24/7

VPS + tmux + Tailscale/SSH. Telegram approvals. Five-method comparison — channels + tmux wins.

25:49 – 28:32

15 · #14 Sub-agents vs skills

Skill = what Claude knows; sub-agent = who does the work. Decision tree.

Atomic Insights

Lines worth screenshotting.

The difference between Claude Code power users and casual users is not prompting skill — it is a set of infrastructure decisions most people never make because they do not know they exist.
UltraCode lets Claude write its own workflow harness for a task and spin out a coordinated team of sub-agents, each with a clean context and a single job.
One UltraCode deep research run used 26 agents, took 13 minutes, and consumed 670,000+ tokens — it is a heavy tool reserved for genuinely complex comprehensive tasks.
Auto mode uses a classifier to approve routine actions on your behalf, so Claude keeps working while only pulling you in for decisions that are genuinely risky.
/loop and /goal together turn a single instruction into a task that reruns on a schedule and will not complete until a stated stop condition is actually met.
Every MCP you connect permanently loads its tool definitions into context and burns tokens before Claude has done anything — stack enough of them and you are paying before work begins.
A CLI tool costs zero tokens until the moment it is called and then forgets the infrastructure; reach for CLI when the action is simple, predictable, and occasional.
Plan mode by default saves to a global disposable folder outside your project; any plan longer than a short session needs to be written into the project itself to survive context compaction.
Each time you correct a broken session instead of rewinding, you add the broken code plus the failure context back into the conversation, making the next output more likely to fail.
Treating Claude Code like a slot machine — resetting and pulling again when a turn goes wrong instead of arguing with it — is the single most counter-intuitive high-leverage habit change.
A skill is what Claude knows how to do; a sub-agent is who does the work — they manage context in different ways, but neither is strictly superior.
Reach for a sub-agent when work would flood the main session with irrelevant context, needs different tools or models, or should run in parallel with other tasks.
Use a skill when you need the intermediate context of the actions taken back in the main conversation thread.
Claude.md is just Anthropic name for agents.md — renaming it is the entire migration path if you ever need to move off Claude Code.
A VPS running Claude Code with tmux plus Telegram-based approvals costs nothing extra if you already have a Pro or Max subscription — no external API cost, no third-party tool needed.

Takeaway

The fourteen decisions that turn Claude Code into an autonomous system.

WHAT TO LEARN

The ceiling on what Claude Code can do for you is set almost entirely by infrastructure choices, and most of them take minutes to implement.

02#1 Dynamic Workflows / UltraCode

UltraCode and dynamic workflows let Claude design its own multi-agent execution plan rather than forcing a single context window to hold an entire complex task — but the token cost is real, so reserve it for genuinely comprehensive work.
The six workflow patterns are composable — Claude mixes them based on the task, and any resulting workflow can be saved as a reusable skill.

03#2 Auto mode

Auto mode is not the same as skipping all permissions — it uses a classifier to handle routine approvals automatically and only surfaces decisions that are actually risky.

04#3 Autonomous long-running tasks

/loop sets a recurring cadence; /goal sets a stop condition; together they produce tasks that run on their own schedule and keep spawning agents until the condition is actually met.

05#4 Skills, built the right way

A well-built skill stays under 200 lines, uses progressive disclosure so heavy reference context only loads when needed, and includes a self-learning rule section updated after each run.

06#5 Skill systems

Skills built as modular Lego blocks can be plugged into multiple skill systems and maintained in one place — one update propagates across every pipeline that uses them.

07#6 MCP vs CLI

Every connected MCP server permanently loads its tool definitions into context before any work begins; CLI tools cost nothing until the moment they are called.

08#7 Memory power-ups

Built-in Claude Code memory search is keyword-based and degrades badly when context is compacted; semantic search frameworks restore past context by meaning.

09#8 Folder structure / Agentic OS

A CLAUDE.md that instructs Claude which context folders to load for which jobs is the difference between Claude reading one flat file and drawing on the right knowledge per task.

10#9 Planning the right way

Plan mode saves plans to a global disposable folder that rarely survives two sessions — any plan that will outlast a single short session needs to be written into a file inside the project itself.

11#10 Rewind, do not argue

Each time you correct a broken session rather than rewinding, you add the broken code plus the failure context back into the conversation window — the fix is /rewind, not clarification.

12#11 Multi-Clauding / Agent View

The agents view groups parallel sessions by repository and status, shifting the work pattern from supervising individual terminal windows to checking goal-completion across a fleet.

13#12 Escape routes

agents.md, SKILL.md, and MCP/CLI connections are open standards — CLAUDE.md is simply Anthropic name for agents.md, so the full migration path off Claude Code is a file rename.

14#13 From anywhere, 24/7

Running Claude Code on a VPS with tmux and a Telegram channel costs nothing extra on a Pro or Max subscription and gives you an always-on machine with phone-based approvals.

15#14 Sub-agents vs skills

Use a sub-agent when the work would flood the main session with irrelevant context, needs different tools or models, or should run in parallel; use a skill when you need the intermediate context of those actions back in the main conversation thread.

Glossary

Terms worth knowing.

UltraCode: A Claude Code keyword that triggers dynamic workflow mode, where Claude designs its own multi-agent execution harness rather than running everything in a single context window.
Dynamic workflow: A Claude Code execution pattern where the model writes a structured plan for a specific task, then spawns a coordinated team of sub-agents to execute it in parallel or sequentially.
Auto mode: A Claude Code permission setting (Shift+Tab twice) that uses a classifier to approve routine file writes and commands automatically, only pausing for actions judged as genuinely risky.
/loop: A Claude Code slash command that runs a prompt or sub-command on a recurring interval up to a maximum of three days.
/goal: A Claude Code slash command that sets a stop condition checked before each turn; if unmet, Claude spawns another agent and continues until it is satisfied.
Skill system: A pipeline of multiple Claude Code skills chained together where the output of one becomes the input of the next, enabling end-to-end automation of a full job.
Progressive disclosure: A skill design pattern where heavy reference context lives in a separate folder and loads only when the step that needs it is active, keeping the main SKILL.md lean.
MCP (Model Context Protocol): A protocol for connecting Claude Code to external tools via a live standing connection; tool definitions load into context permanently whether used in that session or not.
Agentic OS: A folder structure convention where CLAUDE.md specifies which context folders Claude should load for which task types, functioning as an operating-system-level context router.
Slot Machine Theory: The principle that when a Claude Code session produces bad output, the correct response is to roll back with /rewind and retry rather than correcting inside the degraded context.
Context compaction: Claude Code automatic process of summarising older conversation history to stay within the context window; it can lose plan details, which is why long-running plans should be written to project files.
Sub-agent: A Claude Code agent spawned by the main session with its own isolated context window, optionally using different tools, models, or permissions from the parent session.
tmux: A terminal multiplexer that keeps shell sessions alive on a server after the user disconnects, used to run Claude Code on a VPS so tasks continue when the laptop is closed.

Resources

Things they pointed at.

09:30toolAnthropic skill-creator skill

15:15toolMemSearch

16:40toolHermes memory framework

24:10toolTailscale ↗

25:00tooltmux

09:13productAgentic Academy (community) ↗

Quotables

Lines you could clip.

00:06

“The difference is not genius prompting, and it is definitely not your coding ability. It is a handful of setup decisions that most people never make because they do not know what is possible.”

Permission-granting opener that reframes the entire skill ceiling as an infrastructure problem→ TikTok hook↗ Tweet quote

25:51

“A skill is what Claude knows how to do, and a sub-agent is who does the work.”

Single-sentence conceptual unlock; quotable standalone with zero setup→ IG reel cold open↗ Tweet quote

21:00

“When a pull goes bad, do not argue with that machine. You just reset and pull again.”

Counterintuitive behavioral advice stated memorably→ 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.

metaphoranalogy

00:00So a year ago, Boris Cherny, who built ClockCode, said his number one tip was to use plan mode for everything before he let it build a thing. Now his number one tip is to flip on auto mode and stop approving every permission.

00:12So a lot has changed in the last year, and most people are still using the tips from back then. They're treating ClawCode like a slightly better chatbot while a small group are running their entire business through it. The difference isn't genius prompting, and it's definitely not your coding ability.

00:26It's a handful of setup decisions that most people never make because they don't know what's possible. So I've packed 14 of them into this one video, the highest leverage things that I found across thousands of users inside my community. And on their own, they're small changes, but stacked together, they turn ClockCode into a completely different super powered tool.

00:46So let's start straight up with some newer features, and the first one is called UltraCode. And this comes off the back of dynamic workflows. So out of the box, Claude can plan and execute in a single context window, and that's fine for your short non complex tasks.

01:00But on long jobs, the context window degrades in three specific ways. It often stops before it's supposed to finish and declares the job done prematurely. You've probably experienced this.

01:09It also favors its own results when you ask it to judge them. And then it also slowly loses the original objective after the context grows and it begins to compact the context, also known as context raw. So UltraCode lets Claude write its own workflow for a specific task.

01:25It creates a harness for that specific task to be executed. So instead of doing everything itself in one window, it designs a structured plan to best tackle that specific task you've asked it for and then spins out a little or sometimes larger team of sub agents that gives each one a clean context and a single job and coordinates their inputs.

01:43So it's like giving Claude the ability to choose how to divide and conquer that problem. You give it complete autonomy about how it does it so long as it achieves your goal.

01:51And it can even decide which models each agent uses and where the sub agents run-in their own work tree. From a level of effort and reasoning from low to absolutely max, this is on the absolutely max scale.

02:03And there are a few common patterns that Claude might use and compose together when you're building dynamic workflows or using the keyword Ultracode. So here's the six patterns directly from Anthropics docs. So let's go through and talk about when you would use each or when it would use each.

02:17First, we've got classify and act. So it's gonna route the task based on what the task is. So this might be sorting support tickets by the category or type that they are and sending each one down a different path a, and c.

02:28And by the way, anytime you ask it to create these workflows, it can save them much like it does skills to use again. Then we've got the fan out and synthesize. So it's split into many small steps, and it runs an agent on each of the branches and then merges the result.

02:40So this might be deep research. It goes out and does deep research on four different sources, and then we're synthesizing the result at the end. We've got adversarial verification.

02:48So every agent's output gets a second agent checking it, I e verifying it. So it's fact checking a blog draft. One agent makes a claim in the blog, another agent goes to actually try and break that claim.

02:58Then we've got generate and filter, so it generates lots of options then filters down and deduplicates as it goes through. So this is really good for things like brainstorming. Maybe you've got multiple hooks that you're considering and actually you only wanna keep the strongest three, then we generate multiple and deduplicate them and come out with the best at the end.

03:12Tournament where agents as it sounds compete against each other for a winner. And then loop until done, which sounds rather like the Ralph loop, right, where it keeps spawning agents until that stop condition is actually met.

03:23So let's do a quick demo so you can see exactly how it works in action. So we can literally just type in UltraClode, and you can see dynamic workflow requested for this turn. And then we just enter the prompt after UltraClode.

03:33So we'll say perform deep research on ClawCode's latest features in the desktop app. It says I'll run a multi agent research workflow on ClawCode's latest desktop app features.

03:41So it's gonna use the fan out and search agents to search across the change log, desktop specific capabilities, integrations, web slash desktop parity, and then it's gonna deep read the strongest sources and synthesize a cited report. So basically, we're taking this fan out and synthesize approach.

03:56It's gonna go and scout multiple sources and then synthesize at the end. And at any point, we can open this up and see the details by typing in slash workflows. If we hit enter, we can see the log of everything happening.

04:06So we've got these scouts where we've got five different scouts all going to scout the different sources. Then we'll have the deep read phase, the verification phase, and then we'll synthesize those together. So it's really cool how we can see the individual conversations, and we can even go into by hitting enter on any of these and understand exactly what each scout is doing at any stage.

04:23Now it's safe to say this is a heavy way to use tokens, so you only want to use it where it makes sense to have a team of agents with a bunch of clean contacts operating on a comprehensive task. And as you go through, you kinda get status updates.

04:36So you can see this bottom scout here, the news coverage scout has completed, and it took 45,000 tokens. And then once the different scouts are complete, we'll jump into the deep read stage and then go through and see how many tokens it actually took to perform this complete action and what the outputs were at the end. So like it mentioned in the deep read stage next, it's basically picked eight sources, which have now gone to eight agents that it's gonna go through and basically read and understand to a greater level of detail before it verifies it and then synthesizes the result as a report at the end.

05:03But you can see so far it's used 670,000 tokens, so it's not for the faint hearted.

05:09And then we can now come back and see that the deep reads, the verification, and the synthesizing has been done. It says it took 26 agents, thirteen minutes, and now it's gonna read the full report.

05:18But as you can imagine, the more complex the task, the more agents that it assigns to it, the more tokens it uses. So you really only wanna use this if it's a long complex task. And it's important to note it can use a mixture of multiple of these workflow patterns.

05:30It's not just about one. For example, it says adversary verified 12 key claims. And if we go back to this, you can see that adversarial verification was one of the workflow patterns that it uses when it spawns off an agent.

05:42So the next superpower is auto mode. So Boris' top tip this year for saving time and multi clauding was to use the inbuilt auto mode. So by default, ClaudeCode asks for your approval for every single file write and every single command it wants to run.

05:56So it's safe, but it basically chains you to your desktop or to your terminal. Dangerously skip permissions, as you probably saw, does the exact opposite. So it's complete freedom but it's at high risk to your files.

06:06Now auto mode instead uses a classifier that checks each action on your behalf and only stops to ask when something is genuinely risky. So Claude can actually still get on with the work and you only get pulled in for the decisions that actually really matter.

06:19Like, I'm about to delete your file. Is this okay? You can jump to this super easily by shift tabbing twice into auto mode.

06:25You can hand it a task and then you can physically walk away from your desk. Then the next superpower we have is autonomous long running tasks.

06:33So a dream for so many of us. So a normal prompt just runs once and then it stops, and it often stops early. So it would do part of the job, decide for some reason that that's enough or it thinks it's finished, and hand it back half finished.

06:45It probably is sounding quite familiar to be honest if you've used Clog code enough. And up until recently, there's been no built in way to say keep going until this is actually done. So two commands together can actually fix that.

06:57So first of all, we've got slash loop. So run a prompt or slash command on a recurring interval like loop for five minutes or loop every day. So it makes a workflow repeat on a cadence instead of running at once.

07:07Although to be honest, there's a caveat with that one. It runs for maximum three days before turning off automatically. So we input the interval and then we input the prompt, and it will set up that recurring job.

07:16Then we've got slash goal. So set a goal that Claude can check before stopping. And, basically, we input a condition or an end condition that means every turn, it's gonna check.

07:25It has that condition been met. If it has been met, it's gonna stop. If not, it's gonna spawn another agent to try and repeat and continue against that goal.

07:32So when paired together, they actually turn a single instruction to something that runs itself until the outcome you ask for occurs or it hits any of the constraints that you set.

07:41And let's bring it to life with a little bit of an example. Let's think about the tasks that you need to do every day, like clear your inbox, and then the goal that you might have for that inbox, which is like I wanna put all those into the correct folder structure.

07:53So the slash loop means that the prompt will be injected once per day, and then we can enable it to not stop until the conditions are met. So we'd use slash goal to ensure that every item has been moved out of the inbox and filed in a given category. And that might the stock condition.

08:08The inbox is empty after the time of running. So we've given it a goal, connect to my Gmail, file any emails from the last hour into category folders. This could be for the day.

08:15This could be file all emails if you like to keep your inbox at zero. So it says connecting to Gmail, then I'll triage the emails from the last hour into different labeled folders. It's come back to ask for authorization, and we just need to set up the connector to Gmail first.

08:28Now it's successfully connected. We can rerun the goal. And if we wanted to, we would loop this and rerun this prompt every single day.

08:34So it says let me search for threads from the last hour and get the full list of existing labels. It should give us a summary of exactly what's come in and then reorganize those in my inbox. So we've got two threads that have landed in the last hour, both fit in within the promotion category.

08:47So it's gonna file them into promotions, and then it's gonna recheck. Has it achieved everything that meets the end condition of that goal? So it says both threads filed successfully into the promotion category.

08:56Now it's gonna verify that because otherwise, the stop condition might not have been met, and it would spawn another agent to continue until that goal has been met. And there we go.

09:04Goal achieved. Took one minute, one turn, not multiple turns, and 2,003 entry tokens. So now you can basically have a task that runs on its own schedule and won't complete until those conditions are met.

09:14This is super powerful. So that's some of the newer, really powerful features that you can leverage in Cyclore code. But how about some of the older foundations?

09:23Things like skills that we always knew existed, but actually have significantly changed in the last year. So how do we actually get even more out of these and turn those into superpowers? And by the way, if you're enjoying the content so far, I'd highly recommend checking out our AgenTic Academy linked in the description below.

09:39It's where we put all of this thinking into practice with thousands of other business owners. Everyone knows about skills by now. But out the box, without a properly built skill, Claude doesn't activate the skill properly half the time and consumes too many tokens when it's using them.

09:53So as a reminder, a skill is a reusable instruction guide that teaches Claude how you do a specific task. And when built well, it's a succinct Skill. Md file with clean name and description for activation.

10:03So the description saying what triggers it, what shouldn't trigger it and ultimately its end goal or the outcome of the skill. It should also have progressive disclosure built in so the detail or the additional context only loads when it's needed.

10:17And then finally, a built in self learning mechanism. So where each time the skill runs, it gathers feedback and captures it in a rule section inside the skill, which it then reads on next run. So with all that in mind, here's what a good skill looks like today.

10:30We've got a step by step instruction guide under 200 lines because we now know that Claude can load that in really well. We've got however much reference context that we want to add context to those step by step guides. Those are stored in a separate folder, and it means that Claw can load in and offload that context whenever it's needed or not needed anymore in the skill.md.

10:48And then we also know now that Anthropic has a skill creator skill that can help us build these to best practice. So when built correctly, skills themselves can be a superpower, but skills on their own are powerful, but only when they're built so that they can be building blocks for larger systems to tackle certain jobs to be done.

11:07So copywriting skill, for example, should not be so specific that it's for copywriting your meta ads only. It should also be able to be used with any other combination of skills that require any form of writing. I e, it's gonna be reusable, we can plug it into multiple skill systems.

11:21It's gonna be maintainable because everything about copywriting is kept in that specific skill, and therefore we have minimal duplication of that context. And as I alluded to already, this is what we call skill systems. So a skill system is several skills chained together into one workflow, where the output of one skill becomes the input of the next skill.

11:37So you're not building a single skill that does one long process. You're building a pipeline that runs the whole job end to end, and the value lives in that chain, not in the individual parts. The individual parts can be subbed out and maintained as you need.

11:50An example we've got here is our social content creation skill system. A bit of a mouthful, but basically it's end to end social content pipeline. So you have an idea, you have a URL or basically just any form of input topic and it basically comes back with a finished post and a full set of platform ready images or carousel slides like you see on the right hand side.

12:09Now we could have built this into one mega scale, but actually so many of the elements are gonna be reused across all of our visual assets. For example, if we wanna create slides instead of social content, we're gonna reuse a lot of that functionality. And you can see this in itself is made up of 18 different skills.

12:24We've got brand voice, which determines how the copywriting is written. We've got our visual identity, which determines the styles and templates of the actual carousel slides that comes out. We've got ways to actually scrape different content.

12:34So we wanna scrape content from LinkedIn or a URL, then we pull that in a separate tool too. And then we couple that with three different agents to spin off subsets of context for image generation, template builder, etcetera.

12:45But the point here is that you should think of these skills, the 18 skills that go into it, as Lego blocks and build them in that way so they all fit together and you can actually plug and play them as multiple skill systems. And this is one of the superpowers to actually scaling your ClockCode outputs. Because if you think about it, if you've got shared skills that are used by multiple systems, you maintain maintainability and reusability across there.

13:06You change it in one place, and it updates across four different skill systems. And then, of course, they have their own skills which make up the full skill system, but but together, you're able to amplify the outputs because you've got these individual Lego blocks that you can plug and play elsewhere once you build them once.

13:22Now when it comes to connecting Claude to your tools, your everyday tools, there's been a big shift in thinking over the last year. So the question is, do you wire up to your tools using a model context protocol server or an MCP or a command line interface tool, so a CLI? So on its own, clog code is completely sealed off from your tools.

13:39It can think, but it can't touch your calendar or your CRM or your files. So the instinct is to fix that by wiring up everything as an MCP because we've been told that's a unified protocol that everything connects to. But what you need to know is that every MCP you connect to loads its tool definitions into context and keeps them there.

13:55So stacking up multiple MCPs is actually eating thousands of tokens before Claude has even done anything with that MCP. And that's because an MCP is a live standing connection, which is super powerful because Claude always knows the tools that that MCP has access to and what it can actually pull and how to interact with those.

14:11But it's always loaded whether you use it in that session or not. Whereas the CLI allows us to just run a command directly from Claude when it needs it, and then it forgets about the infrastructure. So both actually can reach out to your tools, but the difference is one sits in the context permanently, MCPs, and the other costs you nothing until the moment it's called.

14:28So a quick tip on when to use each. I'd reach for an MCP server when you're interacting with a tool day to day. You've got rich interactions.

14:35You're using multiple tools inside that and where you effectively need Claude to discover and chain the tools. So think like live back and forth with your CRM or a database. If you're using it every day, MCP is the way to go.

14:47It's worth the cost and tokens. But reach for a CLI tool when the action is simple, predictable, occasional, and you're not using that full suite of tools that it has access to.

14:57So think if you're, like, posting a message to a certain place or fetching a file or triggering a script, then a CLI is better than an MCP there. There's no reason to carry the whole tool definition in context all day, every session just for that one line call. Now this next superpower has been one of the hottest topics over the last four months because quite frankly, out of the box, ClaudeCode's memory is quite poor.

15:19Nobody in their right mind wants to spend time reexplaining the same background, the same decisions, the same context that you've previously covered in a session with Claude Code. Yet the outer box functionality for Claude Code means that we're having to do that or we're having to give Claude an external memory layer.

15:34So this would be a memory layer that gives Claude recall that actually survives the session. So it's able to recall past conversations really easily.

15:41So instead of some static file that you have to maintain by hand, we wanna use something like semantic search. So an open source framework like MemSearch is a perfect example. It lets it pull the right piece of past context exactly when it's relevant, and that's because it's searching by meaning and not keywords.

15:57So the inbuilt methods of recall in Cyclore code are all searching by keyword through your previous sessions, which are probably compacted and you lose some of the context there. Whereas when we've got something that does semantic search, we store it in a database, in a vector database, so we can restore things by meaning at very low cost.

16:12And recently, I've made a ton of content about this because it's one of the biggest problems that I see business owners face when they have huge amounts of context but can't recall information correctly. So personally we split it into three ways. It's the storage of information which is how Claude decides when to store info.

16:27It's injection of relevant information back into short term context so we don't have to go and retrieve it. And then finally it's retrieval or recall of those long term memories, the things we said six months ago, three months ago, the cross department decisions that we need access to. And really open source frameworks like MemSearch, which we've already mentioned, Hermes, OpenCLORE, and many others actually leading the charge on best practice for this.

16:49Anthropic is quite behind on this. And for our setup personally, we decided to build our own. So we took the best in class for storage, injection, and recall from MemSearch and Hermes predominantly.

17:00We took their principles, and then we added in our own ability to manage this access across multiple team members where privacy was maintained, but you could still search shared context for any sort of team size.

17:11And you can check down in the link in the description. I'll link to a video where we talk through the different things we've picked out of different memory systems. But it's important to know that things like mem search, you can grab for free off the shelf, and they'll massively improve the ability for Claude to recall your sessions because recall is where it really struggles.

17:28So that brings us next onto a set of foundational concepts that if you skip these, they'll drastically reduce the quality of your outputs. And the first one is so incredibly simple that setting this up today will be the one highest leverage thing you can do after watching this video. So most people have an existing Claude dot m d file, and it's, as you probably know, the file that Claude reads before doing anything.

17:49But not everyone defines in their Claude dot m d how other folders should be used, and therefore, what other context should be used when doing specific jobs. So when done properly, this means a set of folders that separate your own brand context, like how you speak, who you speak to, and your visual identity.

18:07It separates your client's context or different workstations or departments. And ultimately, you might have heard of this as an agentic operating system because this is pretty much what it is. It's a folder structure to inject the right context at the right time to massively improve the output quality that you get out of Claude.

18:23So at its foundation, you can get the structure right, and Claude will load the right context for the right job every single time. And it's all about architecture and writing simple instructions in your claude.md to reference those files at the right time during a task.

18:37So we even reference those files inside our skills, for example. We say, actually, if you need access to the BrandVoice, go and access the brand voice document that's located in this folder. And there's loads of examples online that you can find around how to structure these folders of context, but I'll leave one down below too if you wanna check out a video.

18:54And then the other foundation that people miss is knowing when to plan and how much planning is actually required. So this builds on what we touched on earlier, the dynamic workflows or UltraCode. It's generally amazing for the complex stuff where you need many agents or you need loads of agents operating in parallel.

19:11You saw it did a deep research task, Yeah. I think it was thirteen minutes, highly structured, really well thought out, but most work doesn't need that level of comprehensiveness. Most work is that medium sized task, and the question there is simpler.

19:22Do you just use plan mode, or do you write a product requirements document? And the answer is usually a bit of both. And the part that actually matters is where the plan's gonna end up.

19:31So the old popular advice was to hit shift tab twice to get into plan mode before you tackled any task. And that's still good, but here's the catch that most people don't know. By default, plan mode saves your plan to a global disposable folder outside of your project.

19:45And Clauda is only gonna reliably read it for like one or two times until your context is fully compacted. It will often lose track of that original plan. So anything that's gonna run longer than a short, let's say, less than an hour session, I'd recommend the fix to be actually getting that plan written into a file inside your project folders.

20:02So whether you start in a plan mode session or a written PRD, it matters less than just a plan that actually is gonna be in the project folders and gonna survive all the compacting and clearing of context that's gonna happen through an individual session. And that's because it can be reread into the context and rebuild and understand where it is against that plan.

20:21Wow. So I know we've covered a lot so far, but the last four are what will separate the beginners from the pros. These are some of the most powerful superpowers you can add into ClawCode.

20:29And do me a quick favor. If you've made it this far in the video, hit subscribe below because it genuinely helps you make more content like this. So now we switch it up a gear and go into what I call pro mode.

20:39So these are things learned from thousands of hours, things to improve quality, access, and reliability. And we're gonna start with something called the slot machine theory.

20:47And it's a trap that I fall into so often and almost everyone falls into it too. Now imagine you're having a conversation with Claude, and you're going through that conversation and you're getting it to write a bunch of files, but actually it comes out and it's like misread your instructions or you do a refactor that kind of breaks a few things.

21:03Now your natural instinct is to try and correct that. Type in in something like, no. Not like that, Claude.

21:08Help me fix that. And it's gonna try again. And now what you've done is you've added in that old broken code plus the context of it having broken into that context of the conversation.

21:18So each correction is gonna add more and more context as well as broken code back into that conversation. You'll probably feel this is familiar if you've ever had one of those long conversations where the output is genuinely getting worse, the more information, the more inputs you actually end up giving it.

21:31And the fix comes directly from the Anthropic team themselves. And they say to treat Claude like a slot machine. So when a pull goes bad, don't argue with that machine.

21:40You just reset and pull again. So treat Claude code in exactly the same way. You can use the slash rewind feature.

21:46And instead of telling it, no, fix this, actually just go back to the last check point before it made that mistake. Give it additional context and just spin the wheel again and see what it outputs. So you can use rewind like this because it lets you roll back the code and the conversation to any point earlier in the session.

22:01So it's like a giant undo button. It's something I'm still learning myself to continue to try and do because it's actually against a lot of what feels right and natural as human behavior. We don't want to accept that sunk cost.

22:13And then when you reach the point when you want to operate multiple tasks at the same time, it brings us to our next superpower, which is agent view. Doing multiple tasks at the same time was incredibly hard just a couple of months ago.

22:24You'd be switching between multiple terminal sessions, but now Claude has brought out an agents view, which you can launch by just typing Claude agents. So you can literally jump into individual agents or reply to them at a glance from the dashboard or overview page. It's gonna group the conversations by a certain repository you're working in and also by status so you know which ones actually need a reply.

22:44And it's a super handy way to be working in more of a goal driven way rather than supervising individual sessions. Now number 12 isn't really giving Claude code a superpower per se, but one day there could be a complete rule change, a price hike, or a policy shift that makes your setup with Claude code 10 times more expensive or simply just doesn't suit you anymore.

23:04So if your entire operation only lives inside ClawCode, you've basically got no way out. So think of this one as your escape route from ClawCode if you need it. And the good news here is that the industry has quietly agreed on a set of open standards so that what you build isn't locked into one tool.

23:19So there's kind of three conventions that are gonna be portable between your setups here. We've got an agents.md, which is your shared instructions file that codecs, cursor, copilot, and most other tools already read natively.

23:31So Claude. Md is effectively Claude's equivalent of agents. Md.

23:35You just change the name there. You've got your skills and the skill files in skill. Md.

23:39That's now an open standard too. So the skills can work in other tools. And then your tool connections through your MCPs or your CLIs are supported by every major player too.

23:47So what we're trying to do is make sure that we are super powered by being portable by default. And then you're completely ready to move off of core code if you ever need to. Now that's escaping core code, but what about escaping from sitting at the terminal all day long?

24:02There are couple of built in ways to reach core code from your mobile phone. There's remote control and channels. So talking to it from your phone isn't actually a problem with the existing functionality.

24:11But the moment you disconnect or the session actually times out, the work is gonna stop. So there's no way to do this in the background easily with ClawCode's built in functionality. So setting a job off from your phone on the train and having it still running when you get off isn't possible by default.

24:26But the fix is to run ClawCode somewhere that never sleeps. So a virtual private server or VPS, and then reach it from your phone over a secure channel like SSH or Tailscale. So it's gonna give you an always on machine doing the work in the background and a phone as effectively your your chat interface, your remote control.

24:43So you can still dispatch, approve, and check-in from anywhere without your laptop being involved at all. You can also use the resources of the VPS rather than the resources on your computer.

24:52So I created a comparison of all the different requirements that we'd need to understand across the different channels that we can access it by phone. And the one outstanding winner came in as ClawCode channels, we can still contact it from Telegram and Discord. But pairing that with something like TMux with your VPS to continuously keep it alive.

25:09So all the inbuilt channels have no ability to actually dispatch it and walk away, whereas TMux keeps a persistent session alive. And then combine it with a VPS, you never need your laptop. So basically, you can dispatch tasks and walk away.

25:20And that even includes things like approvals, which are relayed back to Telegram. So all you need to do is approve from Telegram. And it uses your existing pro or max subscription.

25:28So there's no external API cost like using an external service or externally built tool like Clawtell. The only issue here is it's slightly more complex to set up. And I hope in future, Anthropic will build out something that has the ability dispatch and walk away, but also access from your mobile phone.

25:44But as soon as you have this power, it becomes as powerful as something like Hermes and OpenClaw, but you understand exactly what's under the hood. Now I wanted to finish off on one that trips everyone up, how sub agents differ from skills and when to use which. So this is a really misunderstood subject, and people often reach for a sub agent when what they actually are looking for is a skill.

26:04So here's the framing that I use for this personally. A skill is what Claude knows how to do, and a sub agent is who does the work. So a sub agent has its own isolated context, but underneath, effectively, they're the same thing solving the same problem.

26:17All they're doing is managing context. You either have a role or you don't have a role. One's done in isolation.

26:22One's done in the main body of context. And in fact, a skill therefore is basically a sub agent without a role because a role is just context that's applied to a specific task. So sub agents bundle the role and the task together, whereas skills keep them separate.

26:35You get the context of the role through a Claude. M d and then you have the task in the skill. D.

26:39But the way I see it is they're not competing at all. So a skill can hand off to a sub agent whenever it needs to. So here's a quick guide on when to reach for a sub agent versus just using a skill.

26:48I would reach for a sub agent if the work would flood the main session with a bunch of context that is not needed for the main session. I would use a sub agent if it needs different tools, permissions, or a different model because actually you can with a sub agent decide I only want it to access these tools.

27:03I would use a sub agent if you want to run several of the same tasks in parallel because that will speed it up a lot. But instead, I'd use a skill if you actually need that intermediate context back in the main body.

27:14So, basically, if you want to isolate it, keep that context separate, then I'd use a sub agent. But if you need the context of the actual actions taking place, then we'd use a skill. Now I want to show you an example using our LinkedIn Carousel skill system.

27:27So most of it is built out of skills chained together. There's no role, and we have an instruction guide inside this SkilledMD. But when it hits the image generation step, it actually hands off to a sub agent, an image generation sub agent, which is basically just a script running nanobanana pro or GPT image, whatever model the user chooses.

27:44And we do this for two reasons. Firstly, context isolation. So the image generator is gonna basically load heavy style references and run scripts, which the main conversation doesn't need to understand.

27:54The main conversation is running a series of skills to try and output a carousel at the end of it. It doesn't need to know how an image is gonna be generated or that context to pollute it. And then secondly linked to that, we have separation of concerns.

28:05So the orchestrator or your main conversation is just gonna get given the image back. It doesn't need to know how it was made. So, like, effectively both sides are clean.

28:12The worker who's the image generator only knows how to make the image, and it gets the context to make that image, and the main flow never sees the script or the inner workings of how the image been generated. So it's all about context management as a lot of this video has been about too. Right?

28:25Thanks so much for watching. If you want to check out our complete claw code master class, then check the link for the community down in the description below. See you in the next one.

The Hook

The bait, then the rug-pull.

The creator of Claude Code changed his own top tip within a year. That detail opens a video arguing that most users are frozen in 2025 habits while a small group has quietly rebuilt their entire workflow around a set of setup decisions the majority have never made.

Frameworks

Named ideas worth stealing.

02:10list

Six Workflow Patterns (Anthropic)

Classify-And-Act
Fan-Out-And-Synthesize
Adversarial Verification
Generate-And-Filter
Tournament
Loop-Until-Done

The six composable patterns Claude uses when designing dynamic workflows.

Steal forDeep research, content generation pipelines, quality-verification loops

20:34concept

Slot Machine Theory

When a Claude Code session produces broken output, do not correct in the same context. Use /rewind to roll back and retry with additional context.

Steal forAny long Claude Code session; especially refactors or multi-file changes

25:49model

Skills vs Sub-Agents Decision Tree

Skill if you need intermediate context back in the main thread. Sub-agent if context isolation needed, different tools or models, or parallel execution.

Steal forArchitecting any Claude Code workflow with image generation or context-heavy steps

15:09model