How to use the Autonomous Loops Patterns agent skill

What the autonomous-loops skill makes the agent do

The skill is a guidance document. It contains patterns and architectures for autonomous Claude Code loops, ranging from a sequential pipeline to an RFC-driven multi-agent DAG system. When you ask for help designing or setting up a loop, the agent uses these patterns and example scripts as a guide.

The file does not run anything by itself. The scripts it shows are examples that the agent could write or execute for you, so you stay in control of what actually runs.

• Sequential Pipeline (claude -p): a chain of focused, non-interactive steps such as implement, cleanup, verify and commit
• NanoClaw REPL: a session-aware loop that keeps conversation history in a file so sessions persist across restarts
• Infinite Agentic Loop: a two-prompt system where an orchestrator launches parallel sub-agents for spec-driven generation
• Continuous Claude PR Loop: multi-day iterative projects with CI gates
• De-Sloppify Pattern: a cleanup pass that can follow any implementation step
• Ralphinho / RFC-Driven DAG: large features with multi-unit parallel work and a merge queue

How to install the autonomous-loops skill

Download the skill ZIP from this page. Then install it in one of two ways. For a personal setup, unzip it into ~/.claude/skills/. For a single project, unzip it into that project's .claude/skills/ folder.

If you use the Claude apps instead, open Settings, go to Capabilities, then Skills, and upload the ZIP there.

The package contains a single file, SKILL.md.

• Personal install: unzip into ~/.claude/skills/
• Project install: unzip into the project's .claude/skills/ folder
• Claude apps: Settings → Capabilities → Skills, then upload the ZIP

How to trigger the skill with natural requests

You do not need a special command. Describe the workflow you want in plain language and mention loops, pipelines or unattended runs. The agent will pick up the skill when your request matches its scope, which the skill describes as setting up autonomous development workflows, choosing a loop architecture, building CI/CD-style pipelines, running parallel agents, persisting context across iterations, and adding quality gates.

Good requests state the goal, the constraints and the choice you need help with. Vague requests tend to produce generic advice.

• Help me choose between a simple sequential pipeline and a multi-agent design for adding caching to our API.
• Design a claude -p pipeline that implements a spec, runs a cleanup pass, runs tests and then commits.
• Show me how to run parallel sub-agents that each generate a component from docs/component-spec.md.
• Set up a persistent interactive session for exploring this codebase with the tdd-workflow skill loaded.

Understand the main patterns

The skill lists patterns from simplest to most sophisticated. The sequential pipeline is the base case. It breaks work into non-interactive claude -p calls, and each call starts with a fresh context window, so steps do not bleed into each other. Steps run in order, and each one builds on the files the previous step left behind.

The NanoClaw REPL is the interactive option. Each message is sent to claude -p with the full session history, and responses are appended to a Markdown session file. The skill notes that context grows with every turn, while a sequential pipeline gives each step a fresh context.

The infinite agentic loop uses an orchestrator prompt and sub-agent prompts. The orchestrator reads a spec, scans the output directory, and assigns each sub-agent a unique creative direction and iteration number. Batches are sized by count: 1 to 5 agents run at once, 6 to 20 run in batches of 5, and infinite mode runs waves of 3 to 5.

Run a sequential pipeline with claude -p

The skill's example is a Bash script that calls claude -p once per step and uses set -e so a failure stops the pipeline. The steps shown are implement, de-sloppify, verify and commit.

Keep each prompt focused. The skill advises against negative instructions such as telling the agent not to test type systems. Instead, put that work in a separate cleanup step.

For model routing, the examples pass --model opus for research and review steps and leave the default for implementation. To limit what a pass can do, use --allowedTools, for example a read-only audit with Read,Grep,Glob.

• Use files, not long prompts, to pass context. Write a short .claude-context.md, reference it in the prompt, then delete it afterwards.
• Put the de-sloppify cleanup pass after every implementation step.
• Order matters: each step depends on the filesystem state the previous one left.

Start the NanoClaw REPL

NanoClaw is ECC's built-in persistent loop. The skill's examples run it with Node.js. The script it references, scripts/claw.js, is in the ECC repository and is not included in this skill's files, so you need access to that repository to run it.

Sessions are stored as Markdown under ~/.claude/claw/ and reload when you restart. The skill's comparison table says NanoClaw suits interactive exploration and is a poor fit for CI/CD, where the sequential pipeline is the better choice.

• Default session: node scripts/claw.js
• Named session with skill context: set CLAW_SESSION and CLAW_SKILLS before running the script

Use the infinite agentic loop with sub-agents

This pattern is built on a two-prompt system. The skill's example creates a Claude Code command file at .claude/commands/infinite.md. Its arguments are a spec file, an output directory and a count, which is a number or infinite. The command runs in phases: understand the spec, find the highest existing iteration, plan a different creative direction for each agent, deploy sub-agents in parallel with the Task tool, and in infinite mode keep looping in waves until context is low.

The skill credits disler for this pattern.

• Each sub-agent receives the full spec, a snapshot of the current directory, its iteration number and its creative direction
• Iteration numbers are assigned so agents do not write to the same output

Stay safe with unattended runs

The skill itself runs no scripts and uses no network access. The risk comes from what you run after reading it. Autonomous loops can make many changes and commits without review, so the skill's guidance is not suitable for production repositories unless a person checks the output.

Limit the permissions of each pass with --allowedTools, run work on a branch, and review the commits before merging. Treat the example scripts as starting points that you read and adapt, not as finished tools.

• Do not run unattended agents on production repositories without review
• Use read-only tool lists for audit passes
• Check every commit the loop creates before it reaches a shared branch