Claude Code 自主运行完全指南：/goal、/loop、/schedule 与 Stop Hook

Most developers use Claude Code like an assistant they have to babysit.

Type a prompt. Wait. Review. Type again. Wait again.

Every step needs you to push it forward.

There's a completely different way to work. Four commands that let Claude run autonomously until the job is actually done — no babysitting required.

Here's the complete guide to /goal, /loop, /schedule, and Stop hooks.

---

THE SHIFT: FROM ASSISTANT TO AUTONOMOUS AGENT

Normal Claude Code workflow:

You prompt → Claude responds → you review → you prompt again → Claude responds → repeat 20 times.

You are the loop. You are the condition check. You are the reason it keeps going.

Autonomous Claude Code workflow:

You set a condition → Claude works → a fast evaluator checks the condition after every turn → if not done, Claude keeps going → when done, you get a summary.

You set the goal once. Claude runs until it's met.

This is not a minor workflow tweak. This is a fundamentally different relationship with the tool.

COMMAND 1 → /goal

/goal is the most powerful autonomous command in Claude Code. Most developers have never used it.

What it does:

You set a completion condition. After every turn Claude takes, a small fast model (Haiku by default) checks whether the condition has been met by reading the conversation transcript. If not — Claude starts another turn automatically. If yes — you get a "Goal achieved" summary and Claude stops.

You never have to prompt again. Claude keeps working until the condition is true.

How to use it:

/goal all tests in test/auth pass and the lint step is clean

That's it. Claude starts working immediately. No separate prompt needed. The condition itself becomes the directive.

While it's running, a ◎ /goal active indicator shows how long it's been going. Check status anytime:

/goal

This shows: the condition, how long it's been running, how many turns evaluated, tokens spent so far, and the evaluator's most recent reason.

Stop it early:

/goal clear

(stop, off, cancel, reset, and none all work as aliases)

The template for every goal you'll ever write:

/goal [task] until [success condition], verified by [check], while [constraints], or stop after [limit]

Real examples:

/goal migrate auth to the new API until all auth tests pass and unrelated test files are unchanged

/goal refactor the user service until tests pass, or stop after 10 turns

/goal complete the migration, or stop after 30 minutes

Writing good conditions — the most important skill:

The evaluator only reads the conversation transcript. It cannot run commands or open files independently. So your condition must be something Claude's own output can prove.

Good conditions:

→ "All tests in test/auth pass and npm test exits 0"

→ "git status is clean and no other test files are modified"

→ "Every call site in the module compiles with no errors"

→ "Issue backlog queue is empty — verified by running the list command"

Bad conditions:

→ "Do your best on the refactor" — no measurable end state

→ "Looks clean" or "seems right" — subjective, unevaluable

→ "Improve the code" — no way to verify completion

→ Conditions that require reading files the evaluator can't see

Rule: if you can't describe how Claude would prove it's done in the transcript — rewrite the condition until you can.

Add a limit for long tasks:

Always include a turn or time clause on non-trivial goals. Without one, a goal that can't be met will run forever.

/goal fix checkout tests, or stop after 10 turns
/goal complete the migration, or stop after 30 minutes

Claude tracks and reports progress against the limit each turn. The evaluator judges whether the limit has been hit.

Run /goal non-interactively:

claude -p "/goal CHANGELOG.md has an entry for every PR merged this week"

This runs the entire loop to completion in one invocation. Stop it with Ctrl+C. Perfect for CI pipelines and scheduled scripts.

Combine with Auto mode for fully unattended work:

/goal removes per-turn prompts. Auto mode removes per-tool prompts.

Together — Claude works completely unattended until the condition is met or the limit is hit. This is the closest thing to a fully autonomous coding agent available in Claude Code today.

Resume after crash:

If a session ends with an active goal, it restores automatically when you --resume or --continue the session. The condition carries over. Turn count, timer, and token spend reset. Pick up exactly where it stopped.

/goal all tests in test/auth pass and the lint step is clean

/goal [task] until [success condition], verified by [check], while [constraints], or stop after [limit]

/goal migrate auth to the new API until all auth tests pass and unrelated test files are unchanged

/goal refactor the user service until tests pass, or stop after 10 turns

/goal complete the migration, or stop after 30 minutes

/goal fix checkout tests, or stop after 10 turns
/goal complete the migration, or stop after 30 minutes

COMMAND 2 → /loop

/loop runs Claude on repeat on a time interval — not until a condition is met, but on a cadence you define.

Where /goal says "keep going until this is true" — /loop says "keep going every N minutes until I stop you."

Best for:

→ Iterative refactors where you want Claude to make a pass, pause, let you review, then make another

→ Monitoring tasks that need repeated checks

→ Burning down a backlog incrementally — Claude takes one item per loop, you see progress in real time

→ Polling an external state that changes over time

The difference from /goal in one line:

/goal stops when a condition is confirmed true.

/loop stops when you stop it, or when Claude decides the work is done.

COMMAND 3 → /schedule (Scheduled Tasks)

/schedule kicks off Claude on a fixed cadence — independent of any open session. It runs whether or not you have Claude Code open.

Where /goal and /loop keep the current session running — /schedule creates work that happens on its own, in the background, on a timer.

What you can schedule:

Nightly test runs — Claude runs your full test suite at 2am, posts a summary to Slack.

Morning triage — Claude reviews open issues every morning, labels them, flags blockers.

Weekly cleanup — Claude scans for dead code, outdated comments, and TODO items every Sunday.

Daily standup prep — Claude pulls recent commits, open PRs, and failing tests into a summary before your 9am.

The key difference from /goal and /loop:

/goal and /loop require an open session. If you close Claude Code, they stop.

/schedule runs completely independently. You set it once, it runs on its own cadence, forever — or until you cancel it.

This is how you turn Claude Code into infrastructure, not just a tool you use when you remember to open it

COMMAND 4 → STOP HOOKS

A Stop hook gives you programmatic, scriptable control over exactly when Claude is allowed to finish a turn.

/goal uses a Stop hook under the hood — it's a session-scoped prompt-based hook that fires after every turn. But you can write your own Stop hooks for complete custom control.

Two types:

▸ Script-based Stop hooks

Run your actual test suite. Hit a CI endpoint. Check a file exists. Query a database. Any deterministic check — if the script exits 0, Claude can stop. If not, Claude keeps going.

This is the most powerful pattern: Claude works, your tests run, if they fail Claude tries again. No human in the loop at all.

▸ Prompt-based Stop hooks

A model evaluates a natural-language condition against the transcript — exactly like /goal. The difference: Stop hooks live in your settings file and apply to every session in their scope. /goal is session-only and disposable.

When to use a Stop hook vs /goal:

Use /goal when: you want a one-off condition for this session only.

Use a Stop hook when: you want the same evaluation logic applied to every session — or when you need a script to run deterministic checks that a model can't evaluate from a transcript alone.

The combination that changes everything:

/goal + Auto mode + a script-based Stop hook that runs your test suite.

Claude works autonomously. After every turn, your tests run. If they pass — Claude stops. If they fail — Claude reads the failure output and tries again. You come back to a green build or a clear explanation of why it couldn't get there.

CHOOSING THE RIGHT COMMAND

"I want Claude to keep working until tests pass."

→ /goal all tests pass and npm test exits 0

"I want Claude to make iterative passes on a refactor while I review between each one."

→ /loop

"I want my test suite to run every night without me."

→ /schedule

"I want a script to decide when Claude is allowed to stop — not a model."

→ Stop hook (script-based)

"I want the same condition applied to every session automatically."

→ Stop hook (prompt-based, in settings file)

"I want Claude to work completely unattended — no per-turn prompts, no per-tool prompts."

→ /goal + Auto mode

THE QUICK REFERENCE

Set a goal:

/goal [condition]

Check status:

/goal

Stop early:

/goal clear

Run non-interactively:

claude -p "/goal [condition]"

Add a safety limit:

/goal [condition], or stop after [N turns / N minutes]

The master template:

/goal [task] until [success condition], verified by [check], while [constraints], or stop after [limit]

---

Most developers will read this and go back to manually prompting every step.

The ones who set up /goal + Auto mode on their next task will never go back.

Set a condition. Walk away. Come back to a result.

That's the whole idea.

Follow for more Claude Code deep-dives every week.