# 14 GENIUS Ways to Give Claude Code SUPERPOWERS

https://www.youtube.com/watch?v=mNawxNjrR_E

[00:00] So a year ago, Boris Churnney, who built
[00:02] CL code, said his number one tip was to
[00:04] use plan mode for everything before he
[00:07] let it build a thing. Now his number one
[00:09] tip is to flip on auto mode and stop
[00:11] approving every permission. So a lot has
[00:13] changed in the last year, and most
[00:14] people are still using the tips from
[00:16] back then. They're treating Claw Code
[00:18] like a slightly better chatbot while a
[00:20] small group are running their entire
[00:21] business through it. The difference
[00:23] isn't genius prompting, and it's
[00:24] definitely not your coding ability. It's
[00:26] a handful of setup decisions that most
[00:28] people never make because they don't
[00:30] know what's possible. So, I've packed 14
[00:31] of them into this one video. The highest
[00:33] leverage things that I found across
[00:35] thousands of users inside my community.
[00:37] And on their own, they're small changes,
[00:40] but stacked together, they turn Claw
[00:42] Code into a completely different
[00:43] superpowered tool.
[00:46] So, let's start straight up with some
[00:48] newer features. And the first one is
[00:50] called Ultra Code. And this comes off
[00:51] the back of dynamic workflows. So out of
[00:54] the box, Claude can plan and execute in
[00:56] a single context window. And that's fine
[00:58] for your short non-complex tasks. But on
[01:00] long jobs, the context window degrades
[01:02] in three specific ways. It often stops
[01:04] before it's supposed to finish and
[01:06] declares the job done prematurely.
[01:08] You've probably experienced this. It
[01:09] also favors its own results when you ask
[01:11] it to judge them, and then it also
[01:13] slowly loses the original objective
[01:15] after the context grows and it begins to
[01:18] compact the context, also known as
[01:19] context raw. So, Ultra Code lets Claude
[01:22] write its own workflow for a specific
[01:24] task. It creates a harness for that
[01:27] specific task to be executed. So,
[01:28] instead of doing everything itself in
[01:30] one window, it designs a structured plan
[01:32] to best tackle that specific task you've
[01:34] asked it for and then spins out a little
[01:36] or sometimes larger team of sub agents
[01:39] that gives each one a clean context and
[01:41] a single job and coordinates their
[01:43] inputs. So, it's like giving Claude the
[01:44] ability to choose how to divide and
[01:46] conquer that problem. You give it
[01:47] complete autonomy about how it does it
[01:50] so long as it achieves your goal. And it
[01:51] can even decide which models each agent
[01:54] uses and where the sub aents run in
[01:56] their own work tree from a level of
[01:58] effort and reasoning from low to
[02:00] absolutely max. This is on the
[02:02] absolutely maxed scale. And there are a
[02:03] few common patterns that Claude might
[02:05] use and compose together when you're
[02:07] building dynamic workflows or using the
[02:09] keyword ultra code. So here's the six
[02:11] patterns directly from anthropics docs.
[02:13] So let's go through and talk about when
[02:15] you would use each or when it would use
[02:17] each. First, we've got classify an act.
[02:19] So it's going to route the task based on
[02:20] what the task is. So this might be
[02:22] sorting support tickets by the category
[02:24] or type that they are and sending each
[02:26] one down a different path A, B, and C.
[02:28] And by the way, anytime you ask it to
[02:30] create these workflows, it can save them
[02:32] much like it does skills to use again.
[02:34] Then we've got the fan out and
[02:35] synthesize. So it's split into many
[02:36] small steps and it runs an agent on each
[02:38] of the branches and then merges the
[02:40] result. So this might be deep research.
[02:42] It goes out and does deep research on
[02:43] four different sources and then we're
[02:45] synthesizing the result at the end.
[02:46] We've got adversarial verification. So
[02:48] every agent's output gets a second agent
[02:51] checking it, i.e. verifying it. So it's
[02:52] fact-checking a blog draft. One agent
[02:54] makes a claim in the blog. Another agent
[02:56] goes to actually try and break that
[02:58] claim. Then we've got generate and
[02:59] filter. So it generates lots of options,
[03:00] then filters down and dduplicates as it
[03:03] goes through. So this is really good for
[03:04] things like brainstorming. Maybe you've
[03:05] got multiple hooks that you're
[03:07] considering and actually you only want
[03:08] to keep the strongest three. Then we
[03:09] generate multiple and dduplicate them.
[03:11] and come out with the best at the end.
[03:12] Tournament, where agents, as it sounds,
[03:14] compete against each other for a winner.
[03:16] And then loop until done, which sounds
[03:17] rather like the Ralph loop, right? Where
[03:19] it keeps spawning agents until that stop
[03:22] condition is actually met. So, let's do
[03:23] a quick demo so you can see exactly how
[03:25] it works in action. So, we can literally
[03:27] just type in ultra code and you can see
[03:28] dynamic workflow requested for this
[03:30] turn. And then we just enter the prompt
[03:32] after ultraode. So, we'll say perform
[03:34] deep research on claw code's latest
[03:36] features in the desktop app. says, "I'll
[03:38] run a multi-agent research workflow on
[03:39] cloud code's latest desktop app
[03:40] features." So, it's going to use the fan
[03:42] out and search agents to search across
[03:44] the change log desktop specific
[03:46] capabilities, integrations, web/ desktop
[03:48] parity, and then it's going to deep read
[03:50] the strongest sources and synthesize a
[03:52] cited report. So, basically, we're
[03:54] taking this fan out and synthesize
[03:55] approach. It's going to go and scout
[03:57] multiple sources and then synthesize at
[03:59] the end. And at any point, we can open
[04:00] this up and see the details by typing in
[04:02] /workflows. If we hit enter, we can see
[04:05] the log of everything happening. So,
[04:06] we've got these scouts where we've got
[04:08] five different scouts all going to scout
[04:10] the different sources. Then we'll have
[04:11] the deep read phase, the verification
[04:13] phase, and then we'll synthesize those
[04:15] together. So, it's really cool how we
[04:16] can see the individual conversations.
[04:18] And we can even go into by hitting enter
[04:20] on any of these and understand exactly
[04:22] what each scout is doing at any stage.
[04:23] Now, it's safe to say this is a heavy
[04:25] way to use tokens. So, you only want to
[04:27] use it where it makes sense to have a
[04:29] team of agents with a bunch of clean
[04:32] contacts operating on a comprehensive
[04:34] task. And as you go through, you kind of
[04:35] get status updates. So you can see this
[04:37] bottom scout here, the news coverage
[04:38] scout has completed and it took 45,000
[04:40] tokens. Then once the different scouts
[04:42] are complete, we'll jump into the deep
[04:44] read stage and then go through and see
[04:45] how many tokens it actually took to
[04:47] perform this complete action and what
[04:48] the outputs were at the end. So like it
[04:50] mentioned in the deep read stage next.
[04:52] It's basically picked eight sources
[04:54] which have now gone to eight agents that
[04:55] it's going to go through and basically
[04:57] read and understand to a greater level
[04:59] of detail before it verifies it and then
[05:01] synthesizes the result as a report at
[05:03] the end. But you can see so far it's
[05:04] used 670,000 tokens. So it's not for the
[05:08] faint-hearted. And then we can now come
[05:09] back and see that the deep read, the
[05:11] verification, and the synthesizing has
[05:13] been done. It says it took 26 agents, 13
[05:16] minutes, and now it's going to read the
[05:17] full report. As you can imagine, the
[05:19] more complex the task, the more agents
[05:20] that it signs to it, the more tokens it
[05:22] uses. So you really only want to use
[05:24] this if it's a long complex task. And
[05:26] it's important to note, it can use a
[05:28] mixture of multiple of these workflow
[05:30] patterns. It's not just about one. For
[05:32] example, it says adversarily verified 12
[05:34] key claims. And if we go back to this,
[05:36] you can see that adversarial
[05:38] verification was one of the workflow
[05:39] patterns that it uses when it spawns off
[05:41] an agent. So the next superpower is auto
[05:44] mode. So Boris's top tip this year for
[05:47] saving time and multi-clauding was to
[05:49] use the inbuilt auto mode. So by
[05:51] default, Claude Code asks for approval
[05:53] for every single file, write and every
[05:55] single command it wants to run. So it's
[05:57] safe, but it basically chains you to
[05:59] your desktop or to your terminal.
[06:00] Dangerously skip permissions, as you
[06:02] probably saw, does the exact opposite.
[06:04] So, it's complete freedom, but it's at
[06:05] high risk to your files. Now, auto mode
[06:07] instead uses a classifier that checks
[06:10] each action on your behalf and only
[06:12] stops to ask when something is genuinely
[06:14] risky. So, Claude can actually still get
[06:15] on with the work, and you only get
[06:16] pulled in for the decisions that
[06:18] actually really matter, like, I'm about
[06:20] to delete your file, is this okay? You
[06:21] can jump to this super easily by shift
[06:23] tabbing twice into auto mode. You can
[06:26] hand it a task, and then you can
[06:27] physically walk away from your desk.
[06:29] Then the next superpower we have is
[06:31] autonomous longrunning tasks. So a dream
[06:34] for so many of us. So a normal prompt
[06:37] just runs once and then it stops and it
[06:39] often stops early. So it will do part of
[06:41] the job, decide for some reason that
[06:42] that's enough or it thinks it's finished
[06:44] and hand it back half finished. It
[06:46] probably is sounding quite familiar to
[06:47] be honest if you've used claw code
[06:49] enough. And up until recently there's
[06:50] been no built-in way to say keep going
[06:52] until this is actually done. So two
[06:55] commands together can actually fix that.
[06:57] So, first of all, we've got slashloop.
[06:59] So, run a prompt or slash command on a
[07:00] recurring interval like loop for 5
[07:02] minutes or loop every day. So, it makes
[07:03] a workflow repeat on a cadence instead
[07:06] of running it once. Although, to be
[07:07] honest, there's a caveat with that one.
[07:09] It runs for maximum 3 days before
[07:11] turning off automatically. So, we input
[07:13] the interval and then we input the
[07:14] prompt and it will set up that recurring
[07:16] job. Then, we've got /goal. So, set a
[07:18] goal that clog can check before
[07:20] stopping. And basically, we input a
[07:21] condition or an end condition. That
[07:23] means every turn it's going to check has
[07:26] that condition been met? If it has been
[07:27] met, it's going to stop. If not, it's
[07:28] going to spawn another agent to try and
[07:30] repeat and continue against that goal.
[07:32] So, when paired together, they actually
[07:33] turn a single instruction to something
[07:35] that runs itself until the outcome you
[07:37] ask for occurs or it hits any of the
[07:40] constraints that you set. And let's
[07:42] bring it to life with a little bit of an
[07:43] example. Let's think about the tasks
[07:45] that you need to do every day like clear
[07:47] your inbox and then the goal that you
[07:49] might have for that inbox which is like
[07:51] I want to put all those into the correct
[07:52] folder structure. So the slash loop
[07:54] means that the prompt will be injected
[07:56] once per day and then we can enable it
[07:58] to not stop until the conditions are
[08:00] met. So we'd use /goal to ensure that
[08:03] every item has been moved out of the
[08:04] inbox and filed in a given category and
[08:07] that might be the stop condition. The
[08:08] inbox is empty after the time of
[08:09] running. So, we've given it a goal.
[08:11] Connect to my Gmail. File any emails
[08:13] from the last hour into category
[08:14] folders. This could be for the day. This
[08:16] could be file all emails if you like to
[08:17] keep your inbox as zero. So, it says
[08:19] connecting to Gmail. Then, I'll triage
[08:20] the emails from the last hour into
[08:22] different labeled folders. Let's come
[08:24] back to ask for authorization. And we
[08:26] just need to set up the connector to
[08:27] Gmail first. Now, it's successfully
[08:29] connected. We can rerun the goal. And if
[08:31] we wanted to, we would loop this and
[08:32] rerun this prompt every single day. So,
[08:34] it says, let me search for threads from
[08:35] the last hour and get the full list of
[08:36] existing labels. and it should give us a
[08:38] summary of exactly what's come in and
[08:40] then reorganize those in my inbox. So,
[08:42] we've got two threads that have landed
[08:43] in the last hour. Both fit in within the
[08:45] promotion category. So, it's going to
[08:47] file them into promotions and then it's
[08:49] going to recheck has it achieved
[08:50] everything that meets the end condition
[08:52] of that goal. So, it says both threads
[08:54] filed successfully into the promotion
[08:55] category. Now, it's going to verify that
[08:57] because otherwise the stop condition
[09:00] might not have been met and it will
[09:01] spawn another agent to continue until
[09:03] that goal has been met. And there we go.
[09:04] Goal achieved. It took 1 minute, one
[09:06] turn, not multiple turns. and 2,000
[09:08] entry tokens. So now you can basically
[09:09] have a task that runs on its own
[09:11] schedule and won't complete until those
[09:13] conditions are met. This is super
[09:15] powerful. So that's some of the newer
[09:18] really powerful features that you can
[09:19] leverage in Cycl code. But how about
[09:21] some of the older foundations? Things
[09:23] like skills that we always knew existed
[09:26] but actually have significantly changed
[09:27] in the last year. So how do we actually
[09:29] get even more out of these and turn
[09:31] those into superpowers? And by the way,
[09:33] if you're enjoying the content so far,
[09:34] I'd highly recommend checking out our
[09:36] Aentic Academy linked in the description
[09:38] below is where we put all of this
[09:39] thinking into practice with thousands of
[09:42] other business owners. Everyone knows
[09:44] about skills by now, but out the box,
[09:45] without a properly built skill, Claude
[09:48] doesn't activate the skill properly half
[09:49] the time and consumes too many tokens
[09:52] when it's using them. So, as a reminder,
[09:54] a skill is a reusable instruction guide
[09:56] that teaches Claude how you do a
[09:58] specific task. And when built well, it's
[09:59] a succinct skill.md file with clean name
[10:02] and description for activation. So the
[10:04] description saying what triggers it,
[10:06] what shouldn't trigger it, and
[10:07] ultimately its end goal or the outcome
[10:09] of the skill. It should also have
[10:10] progressive disclosure built in. So the
[10:13] detail or the additional context only
[10:15] loads when it's needed. And then
[10:17] finally, a built-in self-learning
[10:19] mechanism. So where each time the skill
[10:20] runs, it gathers feedback and captures
[10:22] it in a rule section inside the skill,
[10:24] which it then reads on next run. So,
[10:26] with all that in mind, here's what a
[10:28] good skill looks like today. We've got a
[10:30] step-by-step instruction guide under 200
[10:32] lines because we now know that Claude
[10:34] can load that in really well. We've got
[10:36] however much reference context that we
[10:37] want to add context to those
[10:40] step-by-step guides. Those are stored in
[10:41] a separate folder and it means that
[10:43] Claude can load in and offload that
[10:45] context whenever it's needed or not
[10:47] needed anymore in the skill.md. And then
[10:49] we also know now that Anthropic has a
[10:50] skill creator skill that can help us
[10:52] build these to best practice. So when
[10:56] built correctly, skills themselves can
[10:58] be a superpower. But skills on their own
[11:00] are powerful, but only when they're
[11:02] built so that they can be building
[11:03] blocks for larger systems to tackle
[11:06] certain jobs to be done. So a
[11:07] copywriting skill, for example, should
[11:09] not be so specific that it's for
[11:10] copyrighting your meta ads only. It
[11:12] should also be able to be used with any
[11:14] other combination of skills that require
[11:16] any form of writing. I.e. it's going to
[11:18] be reusable. We can plug it into
[11:19] multiple skill systems. is going to be
[11:21] maintainable because everything about
[11:23] copywriting is kept in that specific
[11:25] skill and therefore we have minimal
[11:26] duplication of that context. And as I
[11:27] alluded to already, this is what we call
[11:29] skill systems. So a skill system is
[11:31] several skills chained together into one
[11:33] workflow where the output of one skill
[11:35] becomes the input of the next skill. So
[11:37] you're not building a single skill that
[11:38] does one long process. You're building a
[11:41] pipeline that runs the whole job end to
[11:43] end. And the value lives in that chain,
[11:45] not in the individual parts. The
[11:47] individual parts can be subbed out and
[11:49] maintained as you need. An example we've
[11:50] got here is our social content creation
[11:53] skill system. A bit of a mouthful, but
[11:55] basically it's endto-end social content
[11:57] pipelines. So, you have an idea, you
[11:59] have a URL, or basically just any form
[12:01] of input topic, and it basically comes
[12:03] back with a finished post and a full set
[12:05] of platform ready images or carousel
[12:07] slides like you see on the right hand
[12:08] side. Now, we could have built this into
[12:10] one mega scale. But actually, so many of
[12:13] the elements are going to be reused
[12:14] across all of our visual assets. For
[12:16] example, if we want to create slides
[12:17] instead of social content, then we're
[12:19] going to reuse a lot of that
[12:20] functionality. And you can see this in
[12:22] itself is made up of 18 different
[12:23] skills. We've got brand voice, which
[12:25] determines how the copywriting is
[12:27] written. We've got our visual identity,
[12:28] which determines the styles and
[12:30] templates of the actual carousel slides
[12:32] that comes out. We've got ways to
[12:33] actually scrape different content. So,
[12:34] we want to scrape content from LinkedIn
[12:36] or a URL. Then we pull that in a
[12:38] separate tool, too. And then we couple
[12:39] that with three different agents to spin
[12:41] off subsets of context for image
[12:43] generation, our template builder, etc.
[12:45] But the point here is that you should
[12:47] think of these skills, the 18 skills
[12:48] that go into it as Lego blocks and build
[12:50] them in that way so they all fit
[12:53] together and you can actually plug and
[12:54] play them as multiple skill systems. And
[12:56] this is one of the superpowers to
[12:58] actually scaling your clock code
[12:59] outputs. Because if you think about it,
[13:01] if you've got shared skills that are
[13:02] used by multiple systems, you maintain
[13:04] maintainability and reusability across
[13:06] there. change it in one place and it
[13:08] updates across four different skill
[13:10] systems. And then of course they have
[13:11] their own skills which make up the full
[13:13] skill system, but but together you're
[13:15] able to amplify the outputs because
[13:17] you've got these individual Lego blocks
[13:19] that you can plug and play elsewhere
[13:20] once you build them once. Now when it
[13:23] comes to connecting Claude to your
[13:24] tools, your everyday tools, there's been
[13:26] a big shift in thinking over the last
[13:28] year. So the question is, do you wire up
[13:30] to your tools using a model context
[13:32] protocol server or an MCP or a command
[13:34] line interface tool? So a CLI. So on its
[13:36] own, claw code is completely sealed off
[13:39] from your tools. It can think, but it
[13:40] can't touch your calendar or your CRM or
[13:42] your files. So the instinct is to fix
[13:44] that by wiring up everything as an MCP
[13:46] because we've been told that's a unified
[13:48] protocol that everything connects to.
[13:49] But what you need to know is that every
[13:51] MCP you connect to loads its tool
[13:52] definitions into context and keeps them
[13:54] there. So stacking up multiple MCPs is
[13:57] actually eating thousands of tokens
[13:59] before Claude has even done anything
[14:00] with that MCP. And that's because an MCP
[14:02] is a live standing connection, which is
[14:04] super powerful because Claude always
[14:06] knows the tools that that MCP has access
[14:08] to and what it can actually pull and how
[14:10] to interact with those. But it's always
[14:12] loaded whether you use it in that
[14:13] session or not. Whereas a CLI allows us
[14:15] to just run a command directly from
[14:17] Claude when it needs it and then it
[14:19] forgets about the infrastructure. So
[14:20] both actually can reach out to your
[14:21] tools, but the difference is one sits in
[14:24] the context permanently, MCPs, and the
[14:26] other costs you nothing until the moment
[14:28] it's called. So a quick tip on when to
[14:29] use each. I'd reach for an MCP server
[14:31] when you're interacting with a tool
[14:33] dayto-day. You've got rich interactions.
[14:35] You're using multiple tools inside that
[14:37] and where you effectively need Claude to
[14:39] discover and chain the tools. So, think
[14:41] like live back and forth with your CRM
[14:44] or a database. If you're using it every
[14:45] day, MCP is the way to go. It's worth
[14:47] the cost and tokens. But reach for a CLI
[14:50] tool when the action is simple,
[14:52] predictable, occasional, and you're not
[14:54] using that full suite of tools that it
[14:56] has access to. So think if you're like
[14:58] posting a message to a certain place or
[14:59] fetching a file or triggering a script
[15:01] then a CLI is better than an MCP there.
[15:03] There's no reason to carry the whole
[15:05] tool definition in context all day every
[15:08] session just for that one line call. Now
[15:11] this next superpower has been one of the
[15:13] hottest topics over the last 4 months
[15:14] because quite frankly out of the box cla
[15:17] code's memory is quite poor. Nobody in
[15:19] their right mind wants to spend time
[15:21] re-explaining the same background, the
[15:23] same decisions, the same context that
[15:25] you've previously covered in a session
[15:26] with Claude code. Yet, the out of-box
[15:28] functionality for claw code means that
[15:30] we're having to do that or we're having
[15:31] to give Claude an external memory layer.
[15:34] So, this would be a memory layer that
[15:35] gives Claude recall that actually
[15:37] survives the session. So, it's able to
[15:39] recall past conversations really easily.
[15:41] So, instead of some static file that you
[15:43] have to maintain by hand, we want to use
[15:45] something like semantic search. So an
[15:47] open- source framework like mem search
[15:48] is a perfect example. It lets it pull
[15:50] the right piece of past context exactly
[15:53] when it's relevant. And that's because
[15:54] it's searching by meaning and not
[15:56] keywords. So the inbuilt methods of
[15:58] recall in cyclcore code are all
[16:00] searching by keyword through your
[16:01] previous sessions which are probably
[16:03] compacted and you lose some of the
[16:04] context there. Whereas when we've got
[16:06] something that does semantic search, we
[16:08] store it in a database in a vector
[16:09] database. So we can restore things by
[16:11] meaning at very low cost. And recently,
[16:13] I've made a ton of content about this
[16:14] because it's one of the biggest problems
[16:16] that I see business owners face when
[16:17] they have huge amounts of context but
[16:19] can't recall information correctly. So,
[16:22] personally, we split it into three ways.
[16:24] It's the storage of information, which
[16:25] is how Claude decides when to store
[16:27] info. It's injection of relevant
[16:28] information back into short-term context
[16:30] so we don't have to go and retrieve it.
[16:32] And then finally, it's retrieval or
[16:33] recall of those long-term memories, the
[16:36] things we said 6 months ago, 3 months
[16:38] ago, the cross department decisions that
[16:39] we need access to. And really open-
[16:41] source frameworks like memarch which
[16:43] we've already mentioned, Hermes,
[16:45] openclaw and many others actually
[16:46] leading the charge on best practice for
[16:48] this. Anthropic is quite behind on this
[16:51] and for our setup personally we decided
[16:52] to build our own. So we took the
[16:54] best-in-class for storage, injection,
[16:57] and recall from memarch and Hermes
[16:59] predominantly. We took their principles
[17:01] and then we added in our own ability to
[17:02] manage this access across multiple team
[17:04] members where privacy was maintained,
[17:07] but you could still search shared
[17:08] context for any sort of team size. And
[17:11] you can check down in the link in the
[17:12] description, I'll link to a video where
[17:13] we talk through the different things
[17:15] we've picked out of different memory
[17:16] systems. But it's important to know that
[17:18] things like mems search you can grab for
[17:20] free off the shelf and they'll massively
[17:22] improve the ability for claude to recall
[17:24] your sessions because recall is where it
[17:26] really struggles. So that brings us next
[17:29] onto a set of foundational concepts that
[17:31] if you skip these, they'll drastically
[17:33] reduce the quality of your outputs. And
[17:35] the first one is so incredibly simple
[17:37] that setting this up today will be the
[17:39] one highest leverage thing you can do
[17:41] after watching this video. So most
[17:43] people have an existing claude.mmd file
[17:46] and it's as you probably know the file
[17:47] that claude reads before doing anything.
[17:49] But not everyone defines in their
[17:51] claw.md how other folders should be used
[17:54] and therefore what other contexts should
[17:56] be used when doing specific jobs. So
[17:58] when done properly this means a set of
[18:00] folders that separate your own brand
[18:03] context like how you speak, who you
[18:05] speak to and your visual identity. It
[18:07] separates your client's context or
[18:09] different workstations or departments.
[18:11] And ultimately, you might have heard of
[18:12] this as an agentic operating system
[18:15] because this is pretty much what it is.
[18:16] It's a folder structure to inject the
[18:18] right context at the right time to
[18:20] massively improve the output quality
[18:22] that you get out of Claude. So, at its
[18:23] foundation, you can get the structure
[18:25] right and Claude will load the right
[18:27] context for the right job every single
[18:29] time. And it's all about architecture
[18:31] and writing simple instructions in your
[18:33] claude.mmd to reference those files at
[18:36] the right time during a task. So we even
[18:38] reference those files inside our skills
[18:40] for example. We say actually if you need
[18:42] access to the brand voice go and access
[18:44] the brand voice document that's located
[18:46] in this folder. And there's loads of
[18:47] examples online that you can find around
[18:48] how to structure these folders of
[18:50] context but I'll leave one down below
[18:51] too if you want to check out a video.
[18:54] And then the other foundation that
[18:56] people miss is knowing when to plan and
[18:59] how much planning is actually required.
[19:01] So this builds on what we touched on
[19:02] earlier, the dynamic workflows or ultra
[19:04] code. It's genuinely amazing for the
[19:06] complex stuff where you need many agents
[19:08] or you need loads of agents operating in
[19:10] parallel. You saw it did a deep research
[19:12] task in I think it was 13 minutes.
[19:14] Highly structured, really well thought
[19:16] out. But most work doesn't need that
[19:17] level of comprehensiveness. Most work is
[19:19] that medium-sized task. And the question
[19:21] there is simpler. Do you just use plan
[19:23] mode or do you write a product
[19:25] requirements document? And the answer is
[19:27] usually a bit of both. And the part that
[19:28] actually matters is where the plan's
[19:30] going to end up. So the old popular
[19:32] advice was to hit shift tab twice to get
[19:34] into plan mode before you tackled any
[19:36] task. And that's still good. But here's
[19:38] the catch that most people don't know.
[19:39] By default, plan mode saves your plan to
[19:41] a global disposable folder outside of
[19:44] your project. And Claude is only going
[19:46] to reliably read it for like one or two
[19:48] times until your context is fully
[19:50] compacted. it will often lose track of
[19:52] that original plan. So on anything
[19:53] that's going to run longer than a short,
[19:55] let's say less than an hour session, I'd
[19:57] recommend the fix to be actually getting
[19:59] that plan written into a file inside
[20:01] your project folders. So whether you
[20:03] start in a plan mode session or a
[20:05] written PRD, it matters less than just a
[20:08] plan that actually is going to be in the
[20:10] project folders and going to survive all
[20:12] the compacting and clearing of context
[20:13] that's going to happen through an
[20:15] individual session. And that's because
[20:16] it can be reread into the context and
[20:18] rebuild and understand where it is
[20:20] against that plan. Wow. So, I know we've
[20:22] covered a lot so far, but the last four
[20:24] are what will separate the beginners
[20:26] from the pros. These are some of the
[20:27] most powerful superpowers you can add
[20:29] into claw code. And do me a quick favor.
[20:30] If you've made it this far in the video,
[20:32] hit subscribe below because it genuinely
[20:33] helps me make more content like this.
[20:36] So, now we switch it up a gear and go
[20:37] into what I call pro mode. So, these are
[20:39] things learned from thousands of hours,
[20:42] things to improve quality, access, and
[20:44] reliability. And we're going to start
[20:46] with something called the slot machine
[20:47] theory. And it's a trap that I fall into
[20:49] so often. And almost everyone falls into
[20:51] it, too. Now, imagine you're having a
[20:53] conversation with Claude and you're
[20:55] going through that conversation and
[20:56] you're getting it to write a bunch of
[20:57] files, but actually it comes out and
[20:59] it's like misread your instructions or
[21:00] you do a refactor that kind of breaks a
[21:03] few things. Now, your natural instinct
[21:04] is to try and correct that. typing in
[21:06] something like, "No, not like that,
[21:08] Claude. Help me fix that." And it's
[21:09] going to try again. And now what you've
[21:11] done is you've added in that old broken
[21:14] code plus the context of it having
[21:16] broken into that context of the
[21:18] conversation. So each correction is
[21:20] going to add more and more context as
[21:21] well as broken code back into that
[21:23] conversation. You'll probably feel this
[21:24] is familiar if you've ever had one of
[21:25] those long conversations where the
[21:27] output is genuinely getting worse the
[21:29] more information and the more inputs you
[21:31] actually end up giving it. And the fix
[21:32] comes directly from the anthropic team
[21:33] themselves. And they say to treat Claude
[21:36] like a slot machine. So when a pull goes
[21:38] bad, don't argue with that machine. You
[21:40] just reset and pull again. So treat claw
[21:42] code in exactly the same way. You can
[21:44] use the /re feature and instead of
[21:46] telling it, "No, fix this." Actually,
[21:48] just go back to the last checkpoint
[21:50] before it made that mistake, give it
[21:51] additional context and just spin the
[21:53] wheel again and see what it outputs. So
[21:55] you can use rewind like this because it
[21:56] lets you roll back the code and the
[21:58] conversation to any point earlier in the
[22:00] session. So it's like a giant undo
[22:02] button. And it's something I'm still
[22:03] learning myself to continue to try and
[22:05] do because it's actually against a lot
[22:07] of what feels right and natural as human
[22:09] behavior. We don't want to accept that
[22:11] sunk cost. And then when you reach the
[22:14] point when you want to operate multiple
[22:16] tasks at the same time, it brings us to
[22:18] our next superpower, which is agent
[22:20] view. Doing multiple tasks at the same
[22:21] time was incredibly hard. Just a couple
[22:23] of months ago, you'd be switching
[22:24] between multiple terminal sessions. But
[22:26] now Claude has brought out an agents
[22:28] view, which you can launch by just
[22:29] typing Claude agents. So you can
[22:31] literally jumping to individual agents
[22:33] or reply to them at a glance from the
[22:35] dashboard or overview page. It's going
[22:37] to group the conversations by a certain
[22:39] repository you're working in and also by
[22:41] status so you know which ones actually
[22:43] need a reply. And it's a super handy way
[22:45] to be working in more of a goal- driven
[22:46] way rather than supervising individual
[22:48] sessions. Now, number 12 isn't really
[22:51] giving Claude code a superpower, per se,
[22:54] but one day there could be a complete
[22:56] rule change, a price hike, or a policy
[22:58] shift that makes your setup with claw
[23:00] code 10 times more expensive, or simply
[23:03] just doesn't suit you anymore. So, if
[23:04] your entire operation only lives in Cycl
[23:06] code, you've basically got no way out.
[23:08] So, think of this one as your escape
[23:10] route from claw code if you need it. And
[23:12] the good news here is that the industry
[23:13] has quietly agreed on a set of open
[23:15] standards so that what you build isn't
[23:18] locked into one tool. So there's kind of
[23:19] three conventions that are going to be
[23:21] portable between your setups. Here we've
[23:23] got an agents.mmd which is your shared
[23:25] instructions file that codeex cursor
[23:28] copiler and most other tools already
[23:30] read natively. So claw.md is effectively
[23:33] claude's equivalent of agents.md. You
[23:35] just change the name there. You've got
[23:36] your skills and the skill files in
[23:38] skill.md. That's now an open standard
[23:40] too. So the skills can work in other
[23:41] tools. And then your tool connections
[23:43] through your MCPS or your CLI are
[23:45] supported by every major player too. So,
[23:47] what we're trying to do is make sure
[23:48] that we are superpowered by being
[23:51] portable by default, and then you're
[23:52] completely ready to move off of claw
[23:54] code if you ever need to. Now, that's
[23:57] escaping claw code, but what about
[23:59] escaping from sitting at the terminal
[24:01] all day long? There are a couple of
[24:03] built-in ways to reach claw code from
[24:04] your mobile phone. There's remote
[24:06] control and channels, so talking to it
[24:08] from your phone isn't actually a problem
[24:10] with the existing functionality, but the
[24:11] moment you disconnect or the session
[24:13] actually times out, the work is going to
[24:15] stop. So, there's no way to do this in
[24:17] the background easily with claw codes
[24:19] built-in functionality. So, setting a
[24:21] job off from your phone on the train and
[24:22] having it still running when you get off
[24:25] isn't possible by default. But the fix
[24:26] is to run claw code somewhere that never
[24:29] sleeps. So, a virtual private server or
[24:31] VPS and then reach it from your phone
[24:33] over a secure channel like SSH or tail
[24:36] scale. So, it's going to give you an
[24:37] always on machine doing the work in the
[24:39] background and a phone as effectively
[24:41] your your chat interface, your remote
[24:42] control. So you can still dispatch,
[24:44] approve, and check in from anywhere
[24:46] without your laptop being involved at
[24:48] all. You can also use the resources of
[24:50] the VPS rather than the resources on
[24:51] your computer. So I created a comparison
[24:53] of all the different requirements that
[24:55] we'd need to understand across the
[24:57] different channels that we can access it
[24:58] by phone. And the one outstanding winner
[25:00] came in as claw code channels. So we can
[25:02] still contact it from Telegram and
[25:04] Discord, but pairing that with something
[25:06] like T-Max with your VPS to continuously
[25:08] keep it alive. So all the in-built
[25:10] channels had no ability to actually
[25:11] dispatch it and walk away. Whereas T-Mox
[25:13] keeps a persistent session alive and
[25:16] then combine it with a VPS. You never
[25:17] need your laptop. So basically you can
[25:18] dispatch tasks and walk away. And that
[25:20] even includes things like approvals
[25:22] which are relayed back to Telegram. So
[25:24] all you need to do is approve from
[25:25] Telegram. And it uses your existing Pro
[25:27] or Mac subscriptions. So there's no
[25:29] external API cost like using an external
[25:32] service or externally built tool like
[25:33] Clell. The only issue here is it's
[25:35] slightly more complex to set up. And I
[25:37] hope in future that Anthropic will build
[25:39] out something that has the ability to
[25:41] dispatch and walk away but also access
[25:43] from your mobile phone. But as soon as
[25:44] you have this power, it becomes as
[25:46] powerful as something like Hermes and
[25:48] Openclaw, but you understand exactly
[25:50] what's under the hood. Now, I wanted to
[25:52] finish off on one that trips everyone
[25:54] up. How sub agents differ from skills
[25:57] and when to use which. So, this is a
[25:59] really misunderstood subject and people
[26:00] often reach for a sub agent when what
[26:02] they actually are looking for is a
[26:04] skill. So here's the framing that I use
[26:06] for this personally. A skill is what
[26:07] Claude knows how to do and a sub agent
[26:10] is who does the work. So a sub agent has
[26:12] its own isolated context, but underneath
[26:14] effectively they're the same thing
[26:16] solving the same problem. All they're
[26:18] doing is managing context. You either
[26:19] have a role or you don't have a role.
[26:20] One's done in isolation, one's done in
[26:22] the main body of context. And in fact, a
[26:24] skill therefore is basically a sub aent
[26:27] without a role because a role is just
[26:28] context that's applied to a specific
[26:30] task. So sub agents bundle the role and
[26:32] the task together whereas skills keep
[26:34] them separate. You get the context to
[26:36] the role through a claude.md and then
[26:38] you have the task in the skill.md. But
[26:40] the way I see it is they're not
[26:40] competing at all. So a skill can hand
[26:42] off to a sub aent whenever it needs to.
[26:44] So here's a quick guide on when to reach
[26:46] for a sub aent versus just using a
[26:48] skill. I would reach for a sub aent if
[26:49] the work would flood the main session
[26:52] with a bunch of context that is not
[26:54] needed for the main session. I would use
[26:55] a sub agent if it needs different tools,
[26:57] permissions, or a different model
[26:59] because actually you can with a sub
[27:00] agent decide I only want it to access
[27:02] these tools. I would use a sub agent if
[27:04] you want to run several of the same
[27:06] tasks in parallel because that will
[27:08] speed it up a lot. But instead, I'd use
[27:09] a skill if you actually need that
[27:11] intermediate context back in the main
[27:13] body. So basically, if you want to
[27:15] isolate it, keep that context separate,
[27:17] then I'd use a sub agent. But if you
[27:19] need the context of the actual actions
[27:21] taking place, then we'd use a skill. Now
[27:23] I want to show you an example using our
[27:25] LinkedIn carousel skill system. So most
[27:27] of it is built out of skills chained
[27:29] together. There's no role and we have an
[27:31] instruction guide inside this skill.md.
[27:34] But when it hits the image generation
[27:35] step, it actually hands off to a sub
[27:37] agent, an image generation sub aent,
[27:39] which is basically just a script running
[27:40] Nano Banana Pro or GPT image, whatever
[27:42] model the user chooses. And we do this
[27:45] for two reasons. Firstly, context
[27:47] isolation. So the image generator is
[27:49] going to basically load heavy style
[27:50] references and run scripts which the
[27:53] main conversation doesn't need to
[27:54] understand. The main conversation is
[27:55] running a series of skills to try and
[27:57] output a carousel at the end of it.
[27:59] Doesn't need to know how an image is
[28:00] going to be generated or that context to
[28:02] pollute it. And then secondly linked to
[28:03] that we have separation of concerns. So
[28:05] the orchestrator or your main
[28:06] conversation is just going to get given
[28:08] the image back. It doesn't need to know
[28:09] how it was made. So like effectively
[28:11] both sides are clean. The worker who's
[28:13] the image generator only knows how to
[28:15] make the image and it gets the context
[28:16] to make that image. and the main flow
[28:17] never sees the script or the inner
[28:19] workings of how the image has been
[28:20] generated. So, it's all about context
[28:22] management as a lot of this video has
[28:24] been about too, right? Thanks so much
[28:25] for watching. If you want to check out
[28:26] our complete claw code masterass, then
[28:28] check the link for the community down in
[28:30] the description below. See you in the
[28:31] next one.