Big Idea

The argument in one line.

The /goal command converts Claude from a request-response tool into an autonomous task runner by pairing a worker model with a cheap evaluator that checks completion after every turn, but the whole system breaks if you cannot define done in concrete, verifiable terms.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code regularly and keep typing continue to push long tasks forward.
You have batched repeatable knowledge work like content repurposing, research briefs, or data categorization that you want to run hands-off.
You are on a Claude Pro subscription and want to extract more from Claude Code without upgrading your plan.
You have wondered why telling Claude to not stop does not work and want to understand the underlying mechanics.

SKIP IF…

You have not used Claude Code yet; this assumes you are already running it in VS Code or terminal.
You are looking for no-code or browser-based AI automation; this is IDE-first.

TL;DR

The full version, fast.

Claude /goal runs two models simultaneously: a worker doing the actual task and a lightweight Haiku evaluator that checks after every turn whether the goal has been met. The key insight is that the evaluator can only judge based on what the worker reports back and cannot independently verify files or state, so a vague goal condition causes infinite looping and real cost overruns. The fix is a three-part goal structure: a measurable end state, a stated proof check, and explicit constraints. With those in place you can run batched jobs like converting six newsletters into 24 social posts or researching 10 companies entirely unattended.

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 – 01:06

01 · The continue problem

Demonstrates the core pain: Claude stops mid-task on large jobs because the request-response architecture is fundamental, not configurable.

01:06 – 03:07

02 · Introducing /goal

Explains the command syntax: describe the finished state not the task. Shows a tax-categorization example prompt with measurable end state and turn limit.

03:07 – 05:06

03 · How the two-model system works

Worker (Opus/Sonnet) does the task; Haiku evaluator checks completion after every response. Cost breakdown shows the evaluator adds negligible overhead.

05:06 – 08:21

04 · The 200 dollar mistake

Vague conditions cause infinite loops with no native budget cap. Introduces the three-ingredient framework: measurable end state, stated check, constraints. Bad vs good goal condition shown side-by-side.

08:21 – 10:59

05 · Demo 1: Newsletter repurposing

Live demo converting 6 newsletters into LinkedIn posts, 3 Reels scripts, and bullet summaries (24 outputs) using /goal with auto mode in VS Code. Completes in minutes.

10:59 – 13:55

06 · Demo 2: Company research briefs

Live demo using /goal to research 10 companies from an Obsidian list, spawning 10 parallel agents. All 10 briefs complete in 3 minutes with overview, pain points, and outreach angle.

13:55 – 15:27

07 · 3 safety rules

Always set a turn limit. Check /goal status before walking away. Start with one small batch to calibrate confidence before scaling.

Atomic Insights

Lines worth screenshotting.

Telling Claude to not stop does not work because stopping behavior is hardware-level, not instruction-level.
The /goal command runs two simultaneous models: a worker doing the task and a Haiku evaluator asking is the goal met yet after every single response.
Haiku evaluation cost is essentially negligible; the expensive model is the worker, which is why a well-scoped goal saves far more than the evaluator overhead costs.
A vague goal condition gives the evaluator no verifiable finish line and users have reported 200 dollar sessions from this mistake.
There is currently no native budget cap in the /goal system; your only protection is a turn limit built into the goal condition itself.
A good goal condition needs three ingredients: a measurable end state, a stated proof check, and constraints on what must not change.
You can monitor a running goal without interrupting it by typing /goal to get a live dashboard with tokens used, turns elapsed, and the evaluator most recent reason.
/goal clear is your emergency brake and you should know it before you walk away from any running session.
The goal command still pauses for permission by default; you need auto mode enabled for true hands-off execution, which requires the Opus 4.7 model.
Six newsletters into 24 social posts completed in minutes unattended; the same job done manually would take over an hour.
Ten company research briefs with overview, pain points, and outreach angle completed in three minutes via parallel sub-agents.
Goal conditions can be up to 4000 characters long so use every character you need to be specific.
The evaluator most recent reason in the /goal dashboard is the most valuable diagnostic for a broken condition.
Start with one folder, one batch, one small task before scaling to your entire business.

Takeaway

Why defining done is the only prompt that matters.

WHAT TO LEARN

Autonomous AI task completion lives or dies on the precision of your completion condition, not on how clearly you describe the work.

Claude /goal uses a two-model architecture: a worker does the task while a cheap Haiku evaluator checks after every response whether the condition is met, looping until it is.
The evaluator only sees the conversation transcript and cannot independently check your filesystem, so a vague condition gives it no way to confirm completion and it will loop indefinitely.
There is no native budget cap: a runaway session from a poorly written goal can cost 200 dollars or more. Your only protection is a turn limit written into the goal itself.
A verifiable goal condition needs three parts: a measurable end state, a stated proof check where Claude must list what it created, and constraints on what must not be touched.
The evaluator most recent reason in the /goal dashboard is the key diagnostic: if it is nonsensical or circular, cancel and rewrite the condition before spending more tokens.
Batched knowledge work like content repurposing, research briefs, and data categorization is the highest-leverage use case: /goal can complete 10 research briefs in three minutes that would take an hour manually.
Enabling auto mode removes permission pauses but means you have accepted full autonomy; read the Anthropic security document before flipping that switch.
Start with one small batch to calibrate trust in your condition before scaling; the cost of a failed 5-file test is negligible, the cost of a failed 500-file run is not.

Glossary

Terms worth knowing.

/goal command: A Claude Code slash command that accepts a task plus a definition of done, then loops a worker model checked by a lightweight evaluator after each response until the condition is met or a turn limit is hit.
Worker model: The primary Claude model (Opus or Sonnet) that performs the actual task inside a /goal session, reading files, writing content, and running code.
Evaluator model: A fast cheap secondary model (Haiku) that fires after every worker response and answers one question: is the goal condition met yet? It only sees the conversation transcript, not the filesystem directly.
Turn: One full cycle of the worker producing output and the evaluator checking it. A turn limit caps the total number of these cycles.
Auto mode: A Claude Code setting that approves all file edits and shell commands automatically, enabling fully unattended execution. Requires the Opus 4.7 model.
Turn limit: A safety cap written into the goal condition such as stop after 20 turns that forces the session to halt regardless of evaluator verdict, preventing runaway cost.

Resources

Things they pointed at.

00:00toolClaude Code ↗

03:09toolVS Code ↗

06:00linkAnthropic API Console Spend Limits ↗

15:00link/goal command prompts download ↗

15:10productAI Playbook Community Skool ↗

07:20toolHyperagent ↗

07:25toolWispr Flow ↗

07:30toolRelay.app ↗

Quotables

Lines you could clip.

02:17

“It is like writing please keep driving on a sticky note and putting it on the dashboard of a car that does not have a self-driving system. The sticky note does not change the hardware.”

Tight analogy no setup needed instantly explains a counterintuitive technical truth→ TikTok hook↗ Tweet quote

05:21

“I have seen people report spending over 200 dollars in a single fourteen-hour session because of a vague goal condition. And that is a real number.”

Specific dollar figure creates urgency; stands alone as a warning→ IG reel cold open↗ Tweet quote

11:11

“The first draft of 24 pieces of content just got done while I sat here in a matter of minutes, and that is the power of this.”

Payoff line after live demo→ 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.

analogystory

00:00If you've been using Claude for any amount of time, you know how this goes. Right? You give it a task, maybe you want it to take 10 newsletters and turn each one into social media posts.

00:08Claude does the first one, maybe the second one, and then it often stops, hands control back to you. And you're just sitting there typing continue over and over and over again for the next hour. Well, Anthropic just released a new feature inside of Claude code that completely fixes this.

00:23It's called the goal command, and it lets Claude work for hours, literally hours without you touching anything. But here's the thing, if you use it wrong, you're gonna waste a lot of money.

00:32I've seen people spend over like $200 in a single session because they set it up the wrong way, and I don't want that to happen to you. So in this video, I wanna break down exactly what this goal command is, why it's fundamentally different from anything you've been doing with Claude before, how to set it up so it actually works without burning through your wallet, and I'm gonna show you two real use cases that are directly applicable to your business.

00:52Okay. So before I explain what the goal command is, I need to explain the problem that it solves first. So here's what happens when you use Claude right now.

01:00You send it a message, Claude produces one response. Right? And then it stops and waits for you to send the next message.

01:06That's how all chat based AI works, ChatTPT, Gemini, Claude, all of them. And this is fine for simple stuff. Right?

01:12You ask it to write an email, it writes the email, done. But what happens when you give it a bigger job? For example, if you are using Claude code and you ask it to do something fairly large, you're sitting there again typing, yes, I accept.

01:25Yes, I accept. Yes, I accept. And that gets pretty annoying.

01:28Let's say you wanna do tax preparation categorization, which nobody likes to do, and you have a folder with a year's worth of Stripe, PayPal, and platform payout data.

01:38And you want all that information categorized into consistent categories like revenue, fees, or refunds. And you want it to produce a single clean ledger by month.

01:47That's a big task. Claude's gonna start working. It'll go through a few statements and then it's gonna stop and essentially say, hey, here's what I've done so far.

01:55And now you're sitting there typing continue. And you're just babysitting your computer for the next hour until it does this task for you. Now the first thing you're probably thinking is, Rick, can't I just tell Claude not to stop?

02:05And the answer is no. And it's not because Claude is ignoring you. It's because how the technology actually works.

02:10It's like writing please keep driving on a sticky note and putting it on the dashboard of a car that doesn't have a self driving system. The sticky note doesn't change the hardware. Right?

02:20Well, the goal command is your self driving system. Here's how it works. Inside a Claude code, and I'll show you how to get access in just a second, you type forward slash goal and then you describe what done looks like.

02:31Not what you want Claude to do, but the finished results look like. So for our tax prep example, you type something like this where I'm telling it process all CSV files in a particular folder. These are exports.

02:42I'm just basically explaining what they are, and then I'm telling it what exactly I want it to do, and I'm very, very specific here.

02:50And then I'm giving it the constraints. Right? So if a file cannot be parsed or categorized log it, then I'm explaining exactly what done looks like.

02:59Both output files exist here with the correct columns and no missing transactions. And then finally, I'm telling it to stop after 40 turns. Now a turn by the way is one full cycle of work being done and then having it checked.

03:12So that is one cycle. And this giving it a turn limit is just one way to harness it, to keep it from going off and spending way more money than you expected. Hey.

03:21And then I'll click go. And by way, this is Cloud Code within Versus Code, which is how I access Cloud Code every day. Hey.

03:27As you can see here, it's going through. It just it's writing a Python script for me right now. When you set a goal, there are actually two AI models working at the same time.

03:35So model one, this is your worker. This is the main Claude model, Opus or Sonnet. This is the one actually doing the job that you've asked it to do.

03:43It's reading your files, creating your spreadsheets, writing your content, doing the research, whatever it is. Model two is the evaluator. This is separate smaller faster model, Haikyu.

03:53And Haikyu has one job. After every single response that the worker produces, Haikyu jumps in and asks one question.

04:00Is the goal met yet? And if Haikyu decides no, the worker goes back to work, processes more statements until Haiku finally says yes. Everything has been extracted, categorized just the way that the user wanted to.

04:12Now this is where cost comes into play. Because you have two models running, there is a cost to this. But here's the good news.

04:18The evaluator, Haiku, is a very small, very fast, very cheap model. The the cost of Haiku checking the work after each turn is essentially negligible compared to the worker model that's actually doing the heavy lifting.

04:30Again, Sonnet or Opus 4.7, for example, if you choose. Now quick note on access. The ability to use the goal command lives inside Cloud Code.

04:38So if you have a Cloud Pro or Mac subscription, you already have access to Cloud Code. You just need to install it.

04:44It takes about two minutes. There's nothing extra to enable it. And as I mentioned earlier, I access Cloud Code via Versus Code.

04:50You could access it in the desktop version if you want. And once you're in Cloud Code, you just type in forward slash goal and then your command your request along with the definition of done and it will go to work for you. Okay.

05:02So all this sounds amazing. Right? Set it and you walk away and you come back and it's all done for you.

05:07But here's where people get burned and I mean literally like losing a bunch of money. Remember the evaluator, Haiku? Well, it can only judge what Claude has told it in the conversation.

05:17It cannot independently go check your files or verify anything on its own. All it sees is what Claude has reported back to it.

05:24So if your goal condition is vague, if you write something like make everything organized or do a good job or repurpose my newsletters, the evaluator has no way to confirm what that actually even means. Like what does organize mean?

05:38When are newsletters repurposed enough? And here's the thing, as of right now when I'm recording this video, there's no built in budget cap.

05:45There's no native stop after x amount of dollars being spent feature. I've seen people report spending over $200 in a single fourteen hour session because of a vague goal condition.

05:56And that's a real number. Right? That's what I'm saying here.

05:58The whole game with the goal command is being super specific about what done actually looks like. Now you can set platform level budget alerts in your Anthropic API console as an extra safeguard. So for example, you see spend limits here.

06:12You can go to change limits and you can change this number to whatever you're comfortable with. But the real protection is writing a clear condition in the first place, and that's what I'm gonna show you right now. So every good goal condition needs three ingredients.

06:26Ingredient one is a measurable end state. This is something concrete that either exists or it doesn't.

06:32A file that's been created. For example, a specific number of documents in a folder, a spreadsheet with specific columns, Something that the evaluator can look at in the conversation and say, yes, that's there, or no, it's not there.

06:46Ingredient number two is a stated check. How does Claude prove that it's done? This is like telling it, once you're finished, list every file that you created and confirm it matches the original source.

06:58You need Claude to explicitly surface the proof of what it's done. And then ingredient three is the constraints like we talked about earlier.

07:07What must not change along the way? For example, do not modify any files outside of the output folder. This keeps Claude from going rogue and touching things that it shouldn't.

07:18So here's a before and after example of what I'm talking about. Here is a bad condition. Repurpose my newsletters.

07:26That's it. Repurpose them into what? To how many?

07:29Where do they go? The evaluator has no idea when this is done. Claude would just keep repurposing, repurposing, repurposing forever.

07:35Now let's flip that and make it way way better. Every newsletter in the newsletters folder has a corresponding document in output folder containing a LinkedIn post, three Instagram Reel scripts, and a bullet pointed summary.

07:50One document per newsletter named to match the original files. Stop after 20 turns.

07:56See the difference there? The evaluator can totally verify every single part of that. Does every newsletter have a corresponding document?

08:03Are the three outputs in each one? Do the file names match? And there's a safety cap, 20 turns.

08:09And by the way, your request and condition can be up to 4,000 characters long, so you have room to be very, very specific. And you can also cancel a running goal at any time by typing in forward slash goal clear.

08:22That's your emergency break. Know this command before you walk away from your computer. I cannot stress that enough.

08:27Now one more super important thing here. The goal command by itself will still pause and ask you for permission every time it wants to edit a file or run a command. That is a safety feature.

08:39It's there by design. So if you want the true hands off experience where you literally walk away from your computer, you also need to turn on auto approve, which is one of the modes here in Cloud Code. So you could just do auto mode right here.

08:52By the way, you need to be using the Opus 4.7 model for auto mode to show up. And this is also really important. Anthropic has a full security and privacy document.

09:03I'll link to it in the description below. Read it before you flip that switch. It's really important to understand.

09:07And by the way, I'm gonna show you what this looks like in terminal because I'm redoing that thing for you because mine already actually finished. While a goal is running, you can check on it without interrupting the work. You can just type in forward slash goal while it's working for you, and you get this little dashboard, for example.

09:22It shows you the condition, how long it's been running, how many tokens have been used, how many turns, etcetera. And this is the most valuable part, the evaluator's most recent reason. If your condition is badly written, then you can diagnose the problem and cancel with the forward slash goal clear before burning more tokens and essentially more money.

09:39And you can also type in forward slash usage, the usage command, to see your overall credit status so you know exactly where you stand. Alright. So let me show you this in action with some couple of real use cases.

09:50And I'm specifically choosing things that are relevant to you as a business owner, not coding examples. So here's the scenario. I've got a folder of six final newsletter issues that I send out every Sunday morning that I've already written.

10:02And I want each one turned into three different things. A LinkedIn post, three Instagram reel scripts, and a bullet pointed summary of each newsletter.

10:13Now that's six newsletters times four outputs each. That's 24 pieces of content.

10:20And if I did that manually or even with regular Claude going back and forth, I'd be here for at least an hour. So I'm telling it to read every markdown file in this folder here. And then for each file, generate a corresponding output document and then save it to this social output file right here.

10:37And I'm telling it each output document must contain four clearly labeled sections, LinkedIn posts, Instagram real script, Instagram real script number two, Instagram real script number three, and then a bullet pointed summary, and I'm specific with each one of those things and what I'm looking for. And then notice at the very end, I'm very clear on what done looks like.

10:55Confirm each file name process before moving to the next one stop after 30 turns. So let's go ahead and see what this does. And again, I'm using auto mode, right, because I'm just gonna let this go.

11:05So as you can see here, Claude is reading the newsletters, each of them. Now it's generating the social media posts.

11:12Alright. And it's just finished up here. It says goal complete.

11:15All five markdown newsletter files in finals now have matching social output files in the social output directory. And it tells me what each one contains. Gives me the check mark saying it's done.

11:27And then here is the output folder. It has matching file names for each one of the final newsletters. And so if I click into this, we can see the LinkedIn post right here.

11:37Then we can see Instagram real script number one, Instagram real script number two, number three, and then a bullet pointed summary.

11:44And this is actually this is pretty solid. I'm pretty happy with this. Now is every single piece of content perfect and ready to post?

11:50Probably not. Right? You're gonna wanna edit these and add your voice and adjust the hooks.

11:54But the first draft of 24 pieces of content just got done while I sat here in a matter of minutes, and that is the power of this. Okay. Second use case, and this one's a little different because it involves Claude actually doing research using the Internet.

12:07Let's say I have a list of 10 companies that I want to reach out to, maybe for partnerships, maybe for sponsorships, whatever the reason is. And I want a one page brief on each company. What the company does, how big they are, what their likely pain points are, and maybe a suggested angle for my outreach.

12:25Now again, I'm very specific on my request. Right?

12:28So I'm telling it to read companies in a specific text file that I have in my Obsidian And then I'm saying from the from that directory, extract every company name as a discrete items.

12:40And then I'm telling it what exactly to do. So for each company, connect conduct web research, create a markdown file in briefs. So again, I'm really specific on what I'm asking you to do.

12:48And then just like we've been doing in the rest of the video and the use cases here, I'm telling it what done looks like. After each brief is written, log the company name and confirm the file was saved before moving to the next one. When all companies have a corresponding markdown file in briefs, the goal is complete.

13:06Stop after 30 turns. And we'll let it go. And you can see here it spun up a whole bunch of individual agents and then it's telling me what it's doing for each one of these companies.

13:16So it spun up 10 different agents. Okay. And actually that happened way faster than I thought it would.

13:22It's already done all 10 company briefs. They're completed in the briefs, uh, folder here. Alright.

13:28So let's open this up and check one out. Let's look at let's look at Notion, for example. Alright.

13:34So here's the company overview, company size, tech and tools, likely pain points, and suggested outreach angle, opening line, value proposition. And the outreach angle that it's suggesting actually makes a ton of sense for my business. So I really like this.

13:47And again, that took literally three minutes to go through 10 different company researching and doc creation.

13:55You're gonna wanna review these obviously. You're gonna wanna add your own perspective and your own angle if something that it's given you doesn't make sense. But having the first draft of 10 research briefs done for you while you're grabbing coffee, that's game changing.

14:07So again, three rules before you walk away anytime that you set a goal. Number one, always add that safety cap. So stop after 20 turns or stop after 30 turns.

14:18And that means if your condition is off, Claude will stop instead of running all night and costing you real money. Number two, check the goal status like we did before. Before you leave the computer, type in forward slash goal while the goal is working and get a sense of where things are at.

14:33Look at the evaluators most recent reason. Make sure Claude's actually making progress like we like it showed us just a second ago. And number three, just start small with this.

14:40Don't set your first goal to reorganize your entire business. Right? Start with one folder, one batch, one small task that you wanted to go do and get comfortable with how it works.

14:50See the quality of the output and then scale up once you trust it and get more comfortable with it. And look, this is only gonna get better from here. Right?

14:57What we're seeing right now is still early days and it's already this powerful. If you want the commands by the way, the goal commands that I use in today's video, I'll link to them in the description below. You can download them right there.

15:07And if you wanna go deeper with AI in your business, I'll put a link also to my AI playbook community in the description down there. Seven day free trial. Click that.

15:15Come join us. Don't have to pay for a week. If you like it, stay.

15:19If you don't, you can leave at that point too. Again, I've linked to everything in the description below. Thanks as always for watching today's video.

15:24Appreciate you, and I'll see you in the next video.

The Hook

The bait, then the rug-pull.

Every Claude Code user knows the ritual: hand it a big job, watch it churn through two tasks, then sit there typing continue for the next hour. Rick Mulready introduces the /goal command as the escape hatch: a self-driving mode that pairs a worker model with a cheap evaluator and runs until done, no babysitting required.

Frameworks

Named ideas worth stealing.

06:24list

3 Ingredients of a Good Goal Condition

Measurable end state: something concrete that either exists or does not
Stated check: Claude must explicitly list proof it is done
Constraints: what must not change along the way

The three components that make a goal condition verifiable by the Haiku evaluator. Without all three the evaluator cannot confirm completion and will loop indefinitely.

Steal forAny prompt where you want Claude to run autonomously without supervision

13:55list