Big Idea

The argument in one line.

Claude's /goal command automates multi-step tasks by running two AI agents in a worker-boss loop until a verifiable finish line is reached, eliminating the need for manual prompting between steps.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You're a developer or automation-focused creator who has repetitive multi-step tasks (data entry, file processing, categorization) and wants to eliminate manual intervention between steps.
A Claude Code user running into workflows that require constant prompting to continue, and you want autonomous turn-by-turn execution without babysitting.
You're building internal tools or scripts where you can clearly define a verifiable end state, and you're willing to set up auto-approve to let agents run unattended.
A technical founder or ops person managing Claude API usage at scale who needs to understand failure modes and cost controls before deploying /goal in production.

SKIP IF…

You're not using Claude Code or don't have access to the /goal slash command — this breakdown assumes you can already open the tool.
Your work requires human judgment calls or subjective approval between steps; /goal only works with objectively verifiable finish lines that Claude can evaluate alone.

TL;DR

The full version, fast.

Claude Code's new /goal slash command turns the assistant into a self-running worker that grinds on a multi-step task until a verifiable finish line is met, eliminating the constant babysitting of typing keep going. It works because two agents run in tandem: a main worker model (Opus or Sonnet) executes the job while a second boss model reviews every turn and asks whether the goal is met, looping until it confirms completion. To use it well, write a finish line the boss can verify by inspecting concrete artifacts like specific files, folders, or row counts, never vague phrases like make it organized, then add a hard cap such as stop after 30 turns. Enable auto-approve only after you understand the access you are granting, monitor spend with /usage, and start on a small scope before scaling up.

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

01 · Cold open — what is /goal

Sets the hook: /goal is a new slash command that lets Claude work indefinitely without user input until a job is done.

00:31 – 00:48

02 · The babysitting problem

Without /goal, Claude stops after each step and waits for 'keep going' — turning a 1-hour job into a day of babysitting.

00:48 – 02:37

03 · Worker / Boss — how it actually works

Two agents run simultaneously: the Worker (Opus/Sonnet) executes; the Boss checks after every turn whether the finish line is met and either re-kicks the worker or stops.

02:37 – 04:27

04 · Setup: /goal + auto-approve

Two required steps for hands-off operation: type /goal with a finish condition, enable auto-approve. Covers safety tradeoffs of auto-approve. Shows /goal status dashboard (turns, tokens, timer).

04:27 – 05:28

05 · Critical failure mode — vague goals

The most important section. Vague conditions cause infinite loops. Real horror: 4,287,950 tokens, $107.52 wasted. Introduces the verifiable finish line concept with bad/good examples.

05:28 – 05:49

06 · Good goal live demo + safety cap

Shows the correct /goal command typed into Claude Code terminal. Introduces the safety cap: 'stop after 30 turns' appended to every condition.

05:49 – 06:54

07 · Demo 01 — Pizza shop social calendar

15 posts across Instagram/LinkedIn/X with captions, hashtags, and AI-generated images via Nano Banana API, output as a professional PDF. Full result shown.

06:54 – 07:13

08 · Demo 02-04 — More use cases

Dog grooming loyalty program (Paw Perks Rewards), coffee shop daily specials, personalized review replies written in owner voice.

07:13 – 08:07

09 · Cost talk + 3 rules

Pro/Max plan required. Three rules: always add safety cap, check /usage before walking away, start small and scale up. Token cost escalation shown per plan tier.

08:07 – 08:23

10 · Recap + CTA

/goal recipe: set the finish line, Claude works, boss verifies. Subscribe ask + related video end card.

Atomic Insights

Lines worth screenshotting.

The /goal command runs two AI agents simultaneously: a worker that executes and a boss on a different model that evaluates whether the finish line has been met after every step.
Without /goal, Claude completes one step and waits for you to type 'keep going' — the command eliminates babysitting by running the loop autonomously.
The finish line must be verifiable by the boss agent from the conversation transcript alone — vague conditions like 'do a good job' cause infinite loops that burn all your tokens.
Adding a safety cap at the end of your goal condition (stop after 30 turns or 45 minutes) is mandatory — it prevents runaway sessions from billing you for overnight failures.
Auto-approve is required for true hands-off execution — without it, Claude pauses and waits for permission on every file edit even while /goal is active.
A goal condition that specifies which files must exist, which folder structure must be created, and what content must be present is verifiable — vague state descriptions are not.
The boss agent can only confirm the goal from what the worker reports back — it cannot independently inspect your file system.
A vague /goal like 'clean up my files and make everything organized' will run indefinitely because organized has no measurable endpoint the boss can verify.
Running /goal with nothing after it shows you the elapsed time, turn count, and token usage — a built-in dashboard for checking in without interrupting the session.
A year's worth of bank statement PDFs — extract, categorize, and produce a monthly spreadsheet — is the canonical use case: precise finish line, repeatable structure, high babysitting cost if done manually.
The two-agent architecture (worker plus independent reviewer) is what separates /goal from just setting Claude to auto-accept — the judge changes the execution behavior, not just the UX.
Burning a full day's token budget on a single vague /goal task is a known failure mode — specificity in the finish line is the only protection.

Takeaway

Write the finish line before you write the prompt.

The /goal playbook

The command is trivial; the finish condition is everything — vague means infinite loop, specific means done.

Every /goal condition needs three things: a specific artifact, a verifiable state, and a turn/time safety cap.
The boss agent can only check what the worker reports back — it cannot browse your filesystem. Design conditions accordingly.
The worker/boss loop is a reusable architecture — steal it for your own agent orchestration docs and Sessions panel explanations.
Four ready-to-clone use cases: receipt categorization, weekly social calendar PDF, loyalty program card, personalized review replies.
Always run /usage before walking away from a long-running task.
Start with one folder, one batch, one set of reviews — not 'reorganize my entire business.'
The $107.52 horror story is your best hook if you ever teach /goal — open with it.

Glossary

Terms worth knowing.

Slash command: A built-in shortcut typed with a leading forward slash inside an AI coding tool that triggers a specific feature or workflow, as opposed to a free-form prompt.
/goal: A command that hands an AI assistant a single, verifiable finish line and lets it loop on the task autonomously, turn after turn, until that condition is met.
Finish line: A concrete, checkable end state written into the goal — specific files, folders, rows, or outputs that must exist — so a reviewing agent can confirm the work is actually done.
Turn: One round of an AI assistant taking an action and reporting the result, used as the unit of work counted and capped inside an autonomous loop.
Worker/boss loop: An agent pattern where one model does the work and a second model reviews each step against the goal, sending the worker back until the goal is verifiably complete.
Opus / Sonnet: Two tiers of Anthropic's Claude language models — Opus being the higher-capability flagship and Sonnet the balanced mid-tier — used as the underlying engine for the worker agent.
Auto-approve: A setting that lets the AI run commands and edit files without stopping to ask permission for each action, required for fully unattended runs of an autonomous goal.
Token: The unit of text an AI model reads and writes, billed and rate-limited per use; long autonomous loops can burn through a daily token budget quickly.
API: A pay-as-you-go interface for calling an AI model directly from code or tools, where every token used translates to a real-dollar charge instead of a flat subscription.
Pro / Max plan: Paid subscription tiers for Claude that include higher usage allowances needed to run long autonomous tasks without immediately hitting limits.
Safety cap: An explicit stop condition added to a goal — such as a maximum number of turns or a time limit — that forces the loop to end even if the finish line is never reached.
Nano Banana API: A nickname for Google's Gemini image-generation model exposed through an API, used here to produce post images on demand inside an automated content workflow.
/usage: A command that shows current consumption against the plan's limits — turns, tokens, and remaining credits — so a long-running task can be checked mid-flight.

Resources

Things they pointed at.

04:25linkAnthropic Security & Privacy document

05:50toolNano Banana API (image generation)

08:13channelClaude design video (end card)

Quotables

Lines you could clip.

04:30

“The boss can only see what the worker tells it. It can't go check your files on its own.”

Clean one-liner that lands the core constraint — no setup needed→ TikTok hook↗ Tweet quote

04:12

“I've already burned through a day's worth of tokens on one task, and I learned the hard way.”

Admission + stakes — emotionally hooks anyone worried about AI costs→ IG reel cold open↗ Tweet quote

06:48

“This kind of thing right here is what a social media manager would charge hundreds of dollars a month to do, and that's just one example.”

Value anchor — tight ROI statement, no context needed→ newsletter pull-quote↗ Tweet quote

01:30

“You can think of the second worker like the employee's boss.”

Instantly graspable analogy — sets up the whole mechanism in one sentence→ TikTok hook↗ 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.

metaphoranalogystory

Claude just released one of the most powerful tools to date. It's a slash command, and it's called slash goal where you give it a task, and it will work for as long as it takes to get the job done without you having to touch anything. In this video, I'm gonna walk you through how you can use this tool.

I'm gonna show you the magic behind why this works so well, and I'm gonna give you a real example on how this works. But let's start with what slash goal actually is. In Claude code, when you type in forward slash, a little menu pops up with a list of built in commands.

Now these aren't prompts, these are tools. Each one is doing something very specific, and slash goal is one of those commands.

It's brand new. And let me tell you, it's so powerful that I've been using it for the past forty eight hours straight. So here's the problem that slash goal is solving.

Let's say that you have a year's worth of bank statements that are in PDFs, and you want every transaction to be pulled out. You want them categorized into things like food and gas and subscriptions and a monthly spending breakdown that you can put into a spreadsheet at the end.

That's a big job. Without slash goal, Claude will do it. It does a really good job, but it would pull the transactions from the first statement, and then it would stop.

And then it waits for you to type something like keep going. And that keeps happening over and over and over again, and you're just sitting there babysitting your computer for over an hour. Now that's how it used to work, but slash goal fixes that completely.

You type in slash goal followed by one sentence describing exactly when Claude Coach should stop, and then Claude just works turn after turn. It's running on its own until the job is fully complete. Alright.

So take a look at this. You type in slash goal and then a finish line. A finish line is something that can be verified by Claude.

You would type in something like this. Every file in my receipts document has been categorized and summarized into a spreadsheet that exists with totals. That's the finish line.

And then Claude just starts running. And you see that little indicator right here? That shows that the goal is active with a timer.

That's your proof that Claude is working on its own, and it's not waiting for you. It's not waiting for me. It's just going.

But there's something that's really interesting about this. So I wanna talk about why and how this actually works so well. When you set a goal, there's actually two AI agents working at the same time.

There's the main model. That's the actual worker. It's using Opus or Sonnet.

That's the one that's actually doing the job. It's building the files. It's writing the code.

It's organizing your stuff. That's your employee. But the magic, the magic comes in with the second worker.

You can think of the second worker like the employee's boss. After every single step that the worker takes, the boss is jumping in. It's reviewing everything that just happened.

It's asking one simple question. Is the goal net yet? If the boss says no, then it tells the worker exactly why the job's not done yet, and then it kicks off another turn.

The worker goes back to work, and then the boss checks again and again and again, and this loop continues until the boss finally says, yes. That is done.

It is complete. And that is when Claude will stop. And that's the magic behind slash goal.

If you type slash goal with nothing after it, it shows you how long the report's been going. It shows you how many turns. It shows you how many tokens have been used.

It's kind of your your dashboard. You can always check-in on your employee. But let's talk about the setup really quick because I think this is really important.

If you want the full hands off experience where you actually walk away and come back to a project that is completed, you need to do two things. First is type in slash goal. That's the easy part.

We just talked about it. But there's a second thing. The second thing is turning on auto approve.

By default, every time Claude wants to run a command or edit a file, it's gonna ask for permission. It's gonna say, can I do this, or can I run that? If you don't turn on auto approve, Claude will pause and then wait for you to click yes on every single action even when slash goal is running.

But that's okay. That is a safety feature. But if you want it to run automatically, you need auto approved turned on.

Now there are some things to consider here. You are giving AI permission to do everything on its own. The good news here is Claude does have some safety nets built in.

Claude's not gonna run anything dangerous without asking you first. It stays within the project that you're giving it, and you can always set limits on what it's allowed to do. I would say that auto mode's a little bit more of an advanced feature, and you should fully understand what Claude has access to and how your data is being handled before you turn it on.

So Anthropic has a full security and privacy document. I'll link it in the description. Read it.

It's powerful, yes, but you should really be using it responsibly. And there's one more really important thing that we need to talk about in this video because if you get it wrong, slash goal will either run forever, which can waste money or not work or use all of your tokens. And trust me, I've already burned through a day's worth of tokens on one task, and I learned the hard way.

But I'm here to show you what that is so you don't have to learn the hard way. Remember the boss? The boss can only see what the worker tells it.

It can't go check your files on its own. So your goal condition, your finish line, has to be something that the boss can confirm just with what the worker has reported back.

It can't be something vague. You can't say make no mistakes or do a good job. Those are real examples that I've tried, and the boss just has no way to confirm them.

It's too vague. So Claw just spins in a circle and using tokens every single time. For example, you do not wanna say, clean up my files and make everything organized.

How does the boss know when everything's organized? It doesn't. It's too vague.

So Claude will just keep going and going and going, and it won't stop. And it'll use all of your tokens, or if you're using your API, even real money.

Instead, you would say something like this. Every file in my receipts folder has been renamed with the date and the vendor name. It's categorized in the monthly folders, and a spending CSV exist with one row per receipt.

You see the difference there? The second one has a finish line that the boss can actually verify. It's a specific file that needs to exist, a specific folder that needs to be created, something that the boss can look at in the conversation and say, yes.

That is actually done. And there's one more thing. You could always add a safety cap.

At the end of your condition, you can always say something like, stop after 30 turns or stop after forty five minutes. That is your seat belt. If something goes wrong, Claude is going to stop instead of running all night and burning through all your credits.

You always wanna do this every time. Trust me. You wanna add that safety net.

Hey. Before we get started with the demos, if this has been helpful so far, please subscribe, like the video, leave a comment. It's something that will really help out my channel, and, of course, I would really appreciate.

But let's get to some real demos. Okay. So let's say that you own a pizza shop.

You know that you need to be posting on social media every single day, but you don't have the time to do it. You don't have the time to plan it or write it or come up with ideas every single day. And I think most small businesses are like that.

They know they have to do it, but it takes forever to create those. So if we were gonna use the goal command, I would say slash goal and then give it a detailed finish line. Take a look at this one.

It's basically asking Claude to build a full week of social media content for this piece of shop with captions and hashtags and real images that's gonna pull from my Nano Banana API, and it's gonna put it all in a professional PDF for me to use. And if it's not done in 20 turns, it's going to stop. And, of course, the boss is making sure that all 15 posts are there with images before it signs off.

And this is what it looks like. We have a full week content here, 15 posts, three platforms, every caption written, the hashtags, the images, everything is there. I didn't have to do a single thing besides type in that prompt, and then I came back, and here it is.

This kind of thing right here is what a social media manager would charge hundreds of dollars a month to do, and that's just one example. You could use slash goal to build a loyalty program for a dog grooming business or plan a full month of daily specials for a coffee shop or write a personalized response to every single review.

You could generate invoices for all of your clients. Anything that takes multiple steps and takes a lot of time, you can use slash goal to handle it. Now before you run this thing, uh, let's talk about cost.

First, you do need a pro or max plan. So slash goal can get expensive if you're not careful. Like I mentioned before, the boss keeps Claud running until the job is done.

But if your condition is bad, the boss will never be done. It'll never be satisfied, and Claud will just keep going and going through a loop and using your tokens.

Now there are three rules here to help avoid this. Number one, always use that safety net. Again, you can say stop after 25 turns or stop after forty five minutes.

Number two, check your usage before you walk away. You can always type slash usage and see where you're at with your credits. And number three, start small.

You don't need to set your first goal to reorganize your entire business. No. You wanna start with one folder.

You wanna do one batch of receipts or one set of reviews. You wanna get comfortable with it and then scale up. If you do those three things, you should be in a good spot.

But that's slash goal. You set a finish line. Claude's gonna work on its own.

The boss is gonna watch over everything until the job is done. If you feel comfortable, turn on auto approve. If you don't, then don't turn it on.

You're gonna write a specific condition with the safety cap and then let Claude do all of the work. Now a quick plug. If you haven't seen my claw design video, you can check it out here.

I encourage you to do so. And if this helped, leave a like. Please subscribe, and I will see you in the

The Hook

The bait, then the rug-pull.

Claude Code shipped a command that turns one sentence into a self-running agent. Tristen O'Brien spent 48 straight hours with /goal before making this video — and the horror story buried in the middle (4.2 million tokens, $107 burned on one vague prompt) is reason enough to watch the whole thing before you touch it.

Frameworks