0:00
Hey Claude Code users, here's the best
0:01
tip you'll receive today on coding with
0:03
Claude. Anthropic just released a new
0:04
goal {slash} command in Claude Code and
0:06
it will significantly improve your AI
0:08
coding if you start using it properly.
0:10
I'll explain exactly why you want to use
0:12
it and I'll show you exactly how to use
0:14
it and I promise this will be a tool you
0:16
will happily use daily because it's
0:18
about to save you so much time and catch
0:20
bugs in your coding before they ever
0:23
exist. So, really quick, what is goals?
0:26
This is a new command that gives Claude
0:27
Code the ability to autonomously operate
0:30
on completing your coding tasks and
0:32
Claude will keep working on a task until
0:34
the goal of that task is achieved. In
0:37
order to know if Claude achieved that
0:39
task goal, he'll run a separate
0:41
independent Claude session who will
0:43
review the results to ensure the goal
0:45
was met rather than simply having your
0:48
primary Claude say that it's done. And
0:50
guys, this is massive and solves a major
0:53
problem which is Claude hallucinating
0:55
that he finished the task or worse,
0:57
Claude just wants to be lazy and never
0:59
actually completes the task at all even
1:01
though he says he does. Having an
1:02
independent instance of Claude do an
1:04
adversarial review is one of two reasons
1:07
why goals is so powerful. The second big
1:10
reason is this, Claude will keep working
1:12
at completing and verifying your goals
1:15
independently and autonomously until the
1:17
independent Claude session claims the
1:20
goal is achieved. So, think of something
1:22
like Ralph Loop but way more intelligent
1:24
and with an adversarial code review
1:26
process. All right, so here's how you
1:28
use it. First, make sure you're using
1:31
the latest version of Claude Code. Just
1:33
tell Claude, "Please update Claude Code
1:35
CLI to its latest version." When it's
1:37
done, exit Claude and log back in and
1:39
now you'll see the goal {slash} command
1:41
as an option. Second, make sure you
1:43
either have auto mode turned on or
1:45
bypass permissions on in your terminal
1:47
so Claude doesn't ask you a million
1:49
questions and instead just gets to work.
1:51
Third, before you just give Claude some
1:53
random goal, you need to give it two
1:55
things. One, a clear task on what you
1:58
want it to build, fix, debug, refactor,
2:01
etc. And two, you've got to give Claude
2:04
clear criteria on how to verify if the
2:07
task was complete. So, if after hearing
2:09
that, if that gives you some anxiety and
2:11
you're saying, "How am I going to give
2:13
Claude an exact task? Or how am I going
2:16
to give it exact verification criteria?
2:18
How do I even know how to do that?"
2:20
Follow these steps and Claude will
2:22
actually do all of it for you with crazy
2:24
good detail. Now, here's the secret and
2:26
let me emphasize this. Let me emphasize
2:29
this. This is the most important part of
2:31
the process. So, do not fade out now.
2:34
Pay close attention. You need to first
2:36
go through a detailed planning phase
2:38
with Claude on your project. You need to
2:40
ensure that Claude has taken your
2:42
brainstorming ideas, broken them down
2:44
into independent phases and tasks, and
2:47
then logs your plan in his long-term
2:49
memory, which, if you don't currently
2:51
have a long-term memory system to help
2:53
Claude remember your detailed plans,
2:55
watch to the end of the video and I'll
2:57
tell you how you can easily and quickly
2:59
build a world-class memory system today
3:02
before you start fumbling around with
3:04
this process because you need a good
3:06
memory system for Claude to know exactly
3:08
what he's supposed to be doing, how to
3:10
break it down into atomic tasks, and how
3:12
to create verification so he can achieve
3:15
your goals properly. Okay, so now that
3:18
your plan is done, it's saved, simply
3:20
ask Claude the following prompt and I'll
3:22
post this prompt in the description of
3:24
the video. Here's the prompt. Give me
3:26
the next two tasks from our project
3:29
Include verification criteria to ensure
3:33
each task is completed and working. And
3:35
do not exceed 3,500 characters for any
3:39
single task plus verification list. The
3:41
last part about the 3,500 characters,
3:43
it's actually really important because
3:45
goals cannot be more than 4,000
3:47
characters. And the reason I use 3,500
3:49
characters is that I often find that
3:51
Claude doesn't count characters
3:52
accurately. So, give him a 500 character
3:54
buffer. Claude will reply with task one
3:57
and task two along with verification
3:59
criteria. Then go back into Claude code,
4:02
use the {slash} goals command, and paste
4:04
your task and verification criteria, and
4:07
watch Claude start working
4:08
independently. He will work until the
4:11
tasks are independently verified and
4:13
working. Now, one thing you might ask
4:14
is, "Why do you only ask Claude for two
4:17
tasks at a time? Why not ask him for the
4:19
plan's complete task list and go from
4:21
there?" And you certainly can do that if
4:24
you want to, but my recommendation is
4:26
just go two and at most three tasks at a
4:28
time because things change as Claude
4:31
starts to develop your coding project.
4:32
He'll find bugs, he'll find blockers,
4:35
and he'll find different configurations,
4:36
and he may want to revisit the plan in
4:39
his long-term memory and change the
4:41
order of those tasks or phases. So,
4:43
here's my pro tip, and do what you will
4:45
with it, but this is my best
4:47
recommendation for good long-term coding
4:49
results. What I do after every few
4:51
completed tasks, I'll ask Claude to
4:53
review our plan in my Obsidian memory
4:55
system. I'll ask him, "Are we still on
4:58
track to achieve my high-level goals for
5:01
this project?" And I'll ask him, "Review
5:03
the plan as well as any recent
5:04
conversations or session logs in my
5:06
Obsidian brain about this project to
5:09
remember what my high-level goals are,
5:11
and remember what your deliverables are
5:14
so we don't drift." This gives Claude
5:16
the ability to ensure that he's still
5:18
working on a plan that is heading
5:20
towards your deliverable. In my
5:22
experience, Claude will often make
5:24
changes to the plan as we're coding and
5:26
reorder the task list. And this is good
5:28
because he's now working with better
5:30
context on the project's needs to
5:32
achieve your high-level goals. If you
5:34
just power through your original plan,
5:36
in my experience, you're going to later
5:38
stumble over bugs that have to be
5:40
refactored. So, there's my pro tip, take
5:42
it how you will. But, in order for what
5:45
I just described to work, you have to
5:47
have a long-term memory system in place.
5:49
This is foundational to having Claude
5:51
code well for you and achieve your
5:53
remembered goals. You have to give
5:55
Claude code a long-term memory system or
5:57
a second brain because if you don't, he
5:59
will not accurately remember the details
6:01
of your plan. He won't remember the why
6:03
of your project and I'm sorry, he just
6:05
won't. So, if you want a world-class
6:07
second brain memory system built in the
6:09
next 30 minutes for Claude code, just
6:11
reply memory in the comments below and
6:13
I'll send you the installation. I have a
6:15
memory system install in the next 30
6:17
minutes and it will give long-term
6:19
detailed memory to Claude code, Claude
6:21
co-work, open Claude bots, Hermes
6:23
agents, and it even captures Claude's
6:25
internal memory system. Then, just put
6:28
this process on repeat. Simply ask
6:30
Claude to export the next two tasks plus
6:33
verification criteria from your plan and
6:36
keep feeding those tasks back to Claude
6:38
using the slash goals command. You will
6:41
get better results and spend so much
6:43
less time having to debug and refactor
6:46
your projects. Do it right the first
6:48
time. The new goal slash command will
6:50
help you do that. It's a brave new
6:52
world. Don't sleep on AI.
