Claude Code’s
For Windows developers, admins, and increasingly the non-developers using Claude Code as a local automation tool, that distinction determines whether
Anthropic documents
The feature is a session-scoped wrapper around a prompt-based Stop hook. When Claude reaches what would ordinarily be the end of a turn, the system sends the goal and the conversation so far to a smaller, faster evaluator model. Anthropic says that model defaults to Haiku for sessions using the Claude API, though the configured provider can change that behavior.
If the evaluator returns “no,” Claude receives the evaluator’s reason and begins another turn. If it returns “yes,” the goal clears and the session ends. That is why the command can feel dramatically more autonomous than a conventional prompt: it changes the default answer to “should I keep going?” from a one-time judgment by the coding model to a repeatedly checked condition.
Anthropic’s own comparison makes the boundaries clear. Auto mode approves tool calls inside a turn;
But the test prompt cited by MakeUseOf did not establish measurable quality requirements for the richer result. It asked for a single-file habit-tracking app that adds habits, checks them off by day, preserves data after refresh, and has no backend. A basic but working app can satisfy all of that. So can a larger, more polished app. The outlet’s conclusion that the
That is the discrepancy in the popular framing:
There is also no published repeatable benchmark behind the “four check-ins became one” claim. MakeUseOf reports one side-by-side build exercise, not a controlled test across models, prompts, repositories, token budgets, or permission modes. It is useful anecdotal evidence that the feature reduces interruption for one particular task, but not evidence that it reliably produces superior applications.
That makes a goal such as “all tests in
The practical consequence is that
A more defensible habit-tracker goal would specify the required data model and checks: the HTML file must run locally without a web server; a refresh must preserve a checked state; a user must be able to create, remove, and complete habits; and a manual test procedure must be performed and reported. That still does not replace an actual human opening the page in a browser, but it gives Claude a much clearer finish line than “build a habit tracker.”
For production work, a deterministic script remains stronger than a model interpreting a prose objective. A build, unit test, Playwright run, lint step, schema validator, or PowerShell check can establish facts. The agent’s transcript should report those outputs; the human reviewer should inspect the diff and the actual deployed behavior.
On a Windows developer machine, the risk grows when
The best first use is therefore a disposable Git branch or worktree with narrowly scoped permissions. Set the completion target, allow only the commands needed to meet it, and review the diff before merging. For admin tasks, start with read-only inventory, log analysis, report generation, or a dry-run remediation script — not a goal that can alter endpoints until a model decides a vaguely worded “cleanup” task is complete.
Users should also check that they are on Claude Code 2.1.139 or later. The command will not appear on older builds, and a managed environment may intentionally suppress it even after the CLI is updated.
Anthropic provides a status view through
The safeguard is to put a stopping clause in the goal text. Anthropic explicitly recommends language such as “or stop after 20 turns.” Its recent guidance on agent loops goes further: specific completion criteria and explicit caps are the means to prevent a long-running agent from treating ambiguity as an invitation to continue spending.
A sensible goal for a repository might read: “Update the dependency, preserve API compatibility, run the unit and integration test suites, show the final
/goal command is a real native feature, but MakeUseOf’s claim that it turns a four-prompt build into a one-prompt experience needs a narrower reading: it reduces turn-level interruptions by making Claude keep working until a stated condition appears satisfied. It does not independently prove that the resulting code, interface, or data handling is better.
MakeUseOf tested /goal on a browser-only habit tracker and reported a visibly more complete app after one request than it received from the same prompt without the command. Anthropic’s Claude Code documentation confirms the underlying mechanism: /goal sets a completion condition, then a separate small model checks the session after each turn and tells Claude either to continue or to stop. The important detail left out of the headline is that the checker evaluates the conversation transcript, not the project files or the running application.For Windows developers, admins, and increasingly the non-developers using Claude Code as a local automation tool, that distinction determines whether
/goal is a useful unattended workflow or an expensive way to let an agent declare victory over work it has not actually verified.
/goal is a stop-condition loop, not a better prompt parser
Anthropic documents /goal as available in Claude Code version 2.1.139 and later. A user enters the command followed by a condition, such as a request that a migration continue until tests pass and linting is clean. Claude then starts working immediately; it does not wait for a second normal-language instruction after the slash command.The feature is a session-scoped wrapper around a prompt-based Stop hook. When Claude reaches what would ordinarily be the end of a turn, the system sends the goal and the conversation so far to a smaller, faster evaluator model. Anthropic says that model defaults to Haiku for sessions using the Claude API, though the configured provider can change that behavior.
If the evaluator returns “no,” Claude receives the evaluator’s reason and begins another turn. If it returns “yes,” the goal clears and the session ends. That is why the command can feel dramatically more autonomous than a conventional prompt: it changes the default answer to “should I keep going?” from a one-time judgment by the coding model to a repeatedly checked condition.
Anthropic’s own comparison makes the boundaries clear. Auto mode approves tool calls inside a turn;
/goal initiates additional turns after a turn finishes. They work together, but they are not the same setting. MakeUseOf correctly notes that enabling Auto mode can make long goal runs less interruptive, but it describes it too closely as part of the feature’s formula. /goal works without Auto mode; Claude will still stop for tool permissions that have not already been approved.The MakeUseOf test demonstrates persistence, not quality
The habit-tracker comparison reported by MakeUseOf is plausible. Without/goal, Claude Code can implement the literal request — one HTML file, local storage, no backend — and then return control. With /goal, it can perform more rounds of editing before the evaluator permits it to stop. Extra turns create more opportunities to add visual polish, empty states, editing controls, statistics, or other features that were not explicitly requested.But the test prompt cited by MakeUseOf did not establish measurable quality requirements for the richer result. It asked for a single-file habit-tracking app that adds habits, checks them off by day, preserves data after refresh, and has no backend. A basic but working app can satisfy all of that. So can a larger, more polished app. The outlet’s conclusion that the
/goal version was “fully fledged” is an editorial judgment based on the rendered result, not a condition the tool was instructed to verify.That is the discrepancy in the popular framing:
/goal did not inherently make the agent more capable of design or product thinking. It gave the same agent a formal reason to keep iterating. If the objective includes only functional requirements, the agent may spend those extra turns rearranging CSS, adding speculative features, or rewriting working code while the user sees a more attractive outcome and assumes the command itself supplied better judgment.There is also no published repeatable benchmark behind the “four check-ins became one” claim. MakeUseOf reports one side-by-side build exercise, not a controlled test across models, prompts, repositories, token budgets, or permission modes. It is useful anecdotal evidence that the feature reduces interruption for one particular task, but not evidence that it reliably produces superior applications.
Claude’s evaluator cannot inspect what Claude did not show it
Anthropic’s documentation puts a hard technical limit on/goal: the evaluator does not call tools and does not read files independently. It only judges what Claude has surfaced in the transcript.That makes a goal such as “all tests in
test/auth pass and lint is clean” suitable. Claude can run the commands, print their results, and leave evidence for the evaluator. A request such as “make the interface professional,” “organize my Downloads folder well,” or “ensure the app is secure” does not create the same proof trail. The model may describe its work confidently, but the evaluator has no independent access to the rendered UI, the directory state, the browser’s storage behavior, or an external security review.The practical consequence is that
/goal should be written as a verification contract, not an expanded wish list. Anthropic recommends one measurable end state, an explicit check, and constraints that must remain intact. Its own examples focus on test exits, compilation, file counts, acceptance criteria, and empty issue queues — outcomes that can be represented clearly in the session.A more defensible habit-tracker goal would specify the required data model and checks: the HTML file must run locally without a web server; a refresh must preserve a checked state; a user must be able to create, remove, and complete habits; and a manual test procedure must be performed and reported. That still does not replace an actual human opening the page in a browser, but it gives Claude a much clearer finish line than “build a habit tracker.”
For production work, a deterministic script remains stronger than a model interpreting a prose objective. A build, unit test, Playwright run, lint step, schema validator, or PowerShell check can establish facts. The agent’s transcript should report those outputs; the human reviewer should inspect the diff and the actual deployed behavior.
Trusted workspaces and permissions are the real safety boundary
Anthropic requires/goal to run in a workspace where the user has accepted Claude Code’s trust dialog, because the command relies on the hooks system. If an organization sets the managed disableAllHooks policy, /goal is unavailable. That is not an incidental configuration detail: it is the control that prevents a local agent from repeatedly continuing work in a project where its hooks are not authorized.On a Windows developer machine, the risk grows when
/goal is paired with Auto mode and broad shell permissions. The command itself does not change permissions, according to Anthropic, but it can cause Claude to make additional tool-call sequences over multiple turns. An allowlist that was reasonable for reading a repository and running tests may be far too broad if it also permits deletes, package installation, credential access, Git pushes, network calls, or modifications outside the intended working directory.The best first use is therefore a disposable Git branch or worktree with narrowly scoped permissions. Set the completion target, allow only the commands needed to meet it, and review the diff before merging. For admin tasks, start with read-only inventory, log analysis, report generation, or a dry-run remediation script — not a goal that can alter endpoints until a model decides a vaguely worded “cleanup” task is complete.
Users should also check that they are on Claude Code 2.1.139 or later. The command will not appear on older builds, and a managed environment may intentionally suppress it even after the CLI is updated.
Turn limits and token spend need to be part of the prompt
The extra autonomy has a cost. Anthropic says/goal evaluates after every turn using the configured small, fast model and bills those evaluation tokens. It characterizes that overhead as typically minor compared with the main coding turns, but the bigger expense is obvious: a goal that keeps failing its own condition triggers more full agent turns, more tool use, and potentially more expensive model context.Anthropic provides a status view through
/goal with no arguments, showing the current or most recently achieved objective, elapsed time, evaluated turns, token spending, and the evaluator’s latest reasoning. That is useful telemetry, but it is not a budget control by itself.The safeguard is to put a stopping clause in the goal text. Anthropic explicitly recommends language such as “or stop after 20 turns.” Its recent guidance on agent loops goes further: specific completion criteria and explicit caps are the means to prevent a long-running agent from treating ambiguity as an invitation to continue spending.
A sensible goal for a repository might read: “Update the dependency, preserve API compatibility, run the unit and integration test suites, show the final
git diff, and stop after eight turns if the tests do not pass.” It tells Claude what to change, what evidence to produce, what not to break, and when to hand control back rather than improvising indefinitely./goal is valuable because it turns repeated prompting into an explicit completion loop. It is not a substitute for requirements, testing, permission boundaries, or review. The command will save the most time when the user can already state exactly what “done” means — and it will reveal that the real bottleneck was never the number of prompts, but the absence of a testable definition of success.
References
- Primary source: MakeUseOf
Published: 2026-08-06T13:01:12+00:00
Loading…
www.makeuseof.com - Related coverage: code.claude.com
Loading…
code.claude.com - Related coverage: github.com
Loading…
github.com - Related coverage: code.claude.com
Loading…
code.claude.com - Related coverage: moeed.app
Loading…
moeed.app - Related coverage: muhammadusmangm.github.io
Loading…
muhammadusmangm.github.io - Related coverage: aimaker.substack.com
Loading…
aimaker.substack.com - Related coverage: aiskill.market
Loading…
aiskill.market - Related coverage: popularaitools.ai
Loading…
popularaitools.ai - Related coverage: claudecodeformarketers.com
Loading…
claudecodeformarketers.com - Related coverage: claude.com
Loop engineering: Getting started with loops | Claude by Anthropic
Loop engineering with Anthropic's Claude Code: design turn-based, goal, time, and proactive agent loops that run to a stop condition.
claude.com
- Related coverage: anthropic.com
Claude Code by Anthropic | AI Coding Agent, Terminal, IDE
Anthropic's agentic coding tool for developers. Claude Code understands your codebase, edits files, runs commands, and helps you ship faster.www.anthropic.com - Related coverage: claudecode-muenchen.de
Loading…
claudecode-muenchen.de - Related coverage: buders.com
Loading…
www.buders.com - Related coverage: dev.smilehugo.com
Loading…
dev.smilehugo.com - Related coverage: windowscentral.com
Microsoft cancels Claude Code licenses, shifting developers to GitHub Copilot CLI — a move likely driven by financial motives | Windows Central
Claude Code was popular among Microsoft engineers, but the company now wants them to shift to GitHub Copilot CLI.www.windowscentral.com