Anthropic has given Claude Code users a practical blueprint for turning their coding assistant into a persistent autonomous worker. On June 30, the company published a detailed guide to “loop engineering”—a set of four patterns that let Claude repeatedly perform tasks, check its own work, and stop only when a condition is met, even after you’ve closed your laptop.

Formalizing features that had been trickling out, the guide introduces three new slash commands—/goal, /loop, and /schedule—alongside a “proactive” mode that chains them together. The announcement marks a deliberate shift from one-shot prompt-and-response to agents that can run tests, monitor pull requests, process feedback, and make routine repository changes with reduced supervision.

The Four Loop Types, from Turn-Based to Fully Autonomous

Anthropic’s taxonomy groups autonomous work into four categories, each defined by its stopping condition.

Turn-based loops are the familiar interactive model: you send a prompt, Claude acts, checks its work where possible, and then stops for the next instruction. The team recommends encoding repeatable verification steps directly into a project’s SKILL.md file. That way, the agent can perform more checks on its own—like running a linter or checking for broken imports—instead of relying on you to review every turn. The more machine‑verifiable the check, the less you need to supervise.

Goal-based loops use the new /goal command to make completion measurable. You set a concrete target—for example, “Reach a Lighthouse score above 90 on the homepage within five attempts.” Each time Claude is about to stop, an evaluator model checks the latest output against the criteria. If the goal isn’t met, the task is sent back for another pass. This eliminates vague guesswork about “good enough” and lets the loop exit cleanly only when the number is hit or the attempt limit is exhausted.

Time-based loops tackle recurring jobs. The /loop command reruns a prompt on a local interval, similar to a cron job inside your terminal. If you need the task to keep running after you shut down, /schedule moves that loop to the cloud. Typical uses include checking for new PR reviews every 15 minutes, monitoring CI failures, or summarizing a Slack channel each morning.

Proactive loops are the highest tier of automation. They combine schedules, goal checks, skill files, agent workflows, and automatic permissions into a single unattended flow. Imagine a loop that, every hour, scans a feedback channel, picks up any new bug report, triages it, attempts a fix, and posts a reply—all without pausing for human approval. Each subtask exits on its own success condition, while the overarching loop hums along until you manually stop it. Anthropic positions proactive loops for well-defined, continuous streams such as bug triage, dependency upgrades, and migration work; they are not meant for open‑ended creative development.

Under the hood, the mechanics are straightforward. According to the Claude Code Agent SDK documentation, the core agent loop evaluates a prompt, calls tools, consumes the results, and repeats until a response is produced that needs no further tool calls. The SDK also exposes guardrails: a maximum number of tool‑use turns and a maximum dollar budget.

What This Means for Your Daily Workflow

How these loops land depends on what kind of Windows user you are.

For the Solo Developer or Hobbyist

If you’re learning to code or working on a side project, goal‑based loops can automate the boring verification steps. Instead of running the test suite manually after each change, give Claude a /goal like “Make the login‑page tests pass within seven attempts.” The agent will iterate, check the terminal output, and report success or failure. Use turn‑based loops with a SKILL.md file to enforce code‑style checks, so every prompt‑and‑response cycle ends with a clean commit. The result is fewer back‑and‑forth corrections and a faster feedback loop.

For Teams and Power Users

In a team setting, time‑based loops shine. Set up a /loop to poll your repo’s pull‑request API every few minutes and apply feedback automatically. For example, if a reviewer flags a variable name, Claude can read the comment, refactor the code, and push a new commit. Move that job to /schedule so it continues overnight, and wake up to a PR that already addresses most of the nitpicks. Proactive loops can take over first‑pass bug triage: scan incoming issues, label them, and suggest linked commits—all while you focus on high‑priority work.

For IT Administrators and DevSecOps

Governance is where the loop model addresses the two biggest fears of autonomous agents: runaway costs and out‑of‑scope changes. Anthropic’s own guidance emphasizes verification, cost limits, and permissions at every stage. The Agent SDK lets you cap spending per task and enforce a maximum number of turns, so a looping agent can’t drain your API budget chasing an ambiguous instruction. Proactive loops require explicit allow‑listing of tools and file writes, and the company advises users to structure tasks with machine‑verifiable success metrics. For example, rather than asking an agent to “improve the UI,” you require it to raise a Lighthouse accessibility score by 10 points within a set dollar limit. This makes loops auditable and predictable. Windows shops can layer these controls onto existing operational habits: scheduled tasks, CI gates, test suites, PowerShell scripts, and least‑privilege service accounts.

How Autonomous Loops Became the Next Big Thing in AI Coding

The conversation around “loop engineering” didn’t start in a vacuum. Over the past year, figures like Boris Cherny, the creator of Claude Code, and Peter Steinberger, who leads next‑gen agent development at OpenAI, have been publicly advocating for a move away from hand‑crafted prompts. Cherny has said he rarely writes prompts himself now; instead, he builds loops that generate and send prompts to Claude. Steinberger demonstrated an agent that wakes every five minutes, maintains code repositories, and assigns tasks fully autonomously. Google engineer Addy Osmani coined the term “loop engineering” to describe this emerging discipline.

Anthropic’s documentation crystallizes those ideas. The four loop types are not a radical new technology—cron jobs, CI pipelines, and feedback loops have existed for decades—but they unify these patterns under a consistent set of commands and make them accessible inside the editor. What has genuinely changed is the emphasis on the stopping condition. Earlier AI coding assistants required a human to decide when a job was done. By making that decision machine‑determinable—a passing test, a Lighthouse score, a closed issue count—Claude Code turns the agent into a self‑checking system.

Getting Started: A Practical Playbook for Windows Users

You don’t need to redesign your entire workflow overnight. Start with a bounded task that has a clear pass/fail check, and iterate from there.

  1. Install Claude Code on Windows using the official PowerShell setup steps. The same terminal that runs your dev environment now powers persistent agent loops.
  2. Pick one repetitive task that already has an automated test or metric. Good candidates: running a unit‑test suite, linting a folder, checking Lighthouse scores, or summarizing a daily error log.
  3. Encode the verification in a SKILL.md file so the agent can self‑check. For instance, include a script that runs pytest and grep for “FAILED.” The more quantitative the check, the less you need to review.
  4. Experiment with a /goal loop before anything persistent. Try: /goal “Make all tests in the auth module pass” --max-attempts 5. Include a dollar limit (--max-cost 0.50) so a stuck loop doesn’t surprise you.
  5. Move to /loop for recurring local checks. If you want to monitor a PR every 10 minutes, run /loop “Check PR #42 for new review comments and apply them” --interval 600 inside your project directory.
  6. Promote stable tasks to /schedule when you’re confident they work. This keeps them running even after you shut down your machine. Start with a simple morning summary: /schedule “Summarize the last 24 hours of commits in our repo” --at 08:00.
  7. Build a proactive loop only for well‑scoped, continuous processes. A good first candidate is dependency upgrade PRs: have Claude check for new package versions daily, run the test suite, and open a PR if everything passes. Keep the permissions narrow—allow only dependency files and test commands.
  8. Always set a hard stop. Every loop should have a maximum number of attempts, a dollar cap, or both. If you detect no‑progress—the agent keeps modifying the same files without producing a passing check—add a kill switch that terminates the loop after a certain number of empty cycles.
  9. Use scripts for deterministic work. Running a PowerShell script to format files or run a pre‑defined test suite is cheaper and more reliable than asking a model to reason through those steps. Reserve the agent for the parts that require judgment.
  10. Monitor and iterate. Check the loop’s logs and cost after the first few runs. Adjust the success criteria or the attempt limits as needed.

Outlook

Agentic loops are not replacing prompt engineering overnight, but they are rapidly shifting the spotlight. The ability to design a system that verifies itself and knows when to stop is becoming a core skill for developers—on par with writing functions or designing APIs. For Windows users, the integration feels familiar because it maps onto existing automation habits. The next evolution will likely bring tighter integration with Windows services, more granular permission models, and better audit trails so teams can track exactly what an autonomous agent did while nobody was watching. For now, grabbing a repetitive task and turning it into a /goal loop is the simplest way to see—and control—the future of coding.