$ ~/registry/skill/affaan-m-autonomous-loops

SKILL

autonomous-loops

Design and choose autonomous Claude Code loop architectures and implementation patterns.

Stars

★ 243,958

Source

GitHub

Updated

2026-08-28

// securityLow risk

Prompt only, no code
Open source
Community-trusted· 244.0k

Running security audit…

Credentials
Network egress
Code execution
Data access
Supply chain

// install

Copy the install command and let the AI configure it · recommended for beginners

Please install the "autonomous-loops" skill from askskill:
1. Download https://raw.githubusercontent.com/affaan-m/ECC/main/skills/autonomous-loops/SKILL.md
2. Save it as ~/.claude/skills/autonomous-loops/SKILL.md
3. Reload skills and tell me it's ready

// download

Download SKILL.mdInstall manifest ↗

// examples

Choose the right loop pattern

Prompt

I want Claude Code to autonomously develop a medium-complexity feature and validate each iteration. Based on autonomous-loops patterns, compare the sequential pipeline, continuous PR loop, and RFC-driven DAG, then recommend the best option with reasons.

Expected

A comparison of loop architectures, their best-fit scenarios, and a recommended approach.

Generate a sequential pipeline prompt set

Prompt

Create an autonomous-loops style sequential pipeline for implementing OAuth2 login, including implementation, cleanup, verification, and commit steps. Output prompts that can be directly used with claude -p.

Expected

A step-by-step set of non-interactive prompts that can be chained into an automated development workflow.

Design a parallel multi-agent plan

Prompt

I have a large feature that should be split into parallel development units. Based on autonomous-loops, explain how to use RFC-driven multi-agent DAG orchestration, including merge coordination, quality gates, and context persistence recommendations.

Expected

A parallel autonomous workflow design for a large project.

// use cases

Set up unattended development workflows

When developers or teams want Claude Code to keep executing development tasks with minimal human intervention, this skill helps them choose a suitable loop pattern and structure the workflow.

Build iterative workflows with quality gates

It fits scenarios where code should iterate continuously like CI/CD, with verification, cleanup, and quality checks added to the loop to reduce poor outputs in later iterations.

Organize parallel agent development for large features

When a large feature must be split into parallel work units, its RFC-driven multi-agent DAG pattern can guide parallel execution and merge coordination.

// docs

AI summary

The README explains patterns for running Claude Code in autonomous loops, ranging from simple claude -p sequential pipelines to interactive sessions, continuous PR loops, cleanup passes, and RFC-driven multi-agent DAG orchestration. It highlights when to use each pattern, how complexity increases across the spectrum, and how to add parallel coordination, context persistence, and quality gates to continuous development workflows.

Show full docs ▾

Autonomous Loops Skill

Compatibility note (v1.8.0): autonomous-loops is retained for one release. The canonical skill name is now continuous-agent-loop. New loop guidance should be authored there, while this skill remains available to avoid breaking existing workflows.

Patterns, architectures, and reference implementations for running Claude Code autonomously in loops. Covers everything from simple claude -p pipelines to full RFC-driven multi-agent DAG orchestration.

When to Use

Setting up autonomous development workflows that run without human intervention
Choosing the right loop architecture for your problem (simple vs complex)
Building CI/CD-style continuous development pipelines
Running parallel agents with merge coordination
Implementing context persistence across loop iterations
Adding quality gates and cleanup passes to autonomous workflows

Loop Pattern Spectrum

From simplest to most sophisticated:

Pattern	Complexity	Best For
Sequential Pipeline	Low	Daily dev steps, scripted workflows
NanoClaw REPL	Low	Interactive persistent sessions
Infinite Agentic Loop	Medium	Parallel content generation, spec-driven work
Continuous Claude PR Loop	Medium	Multi-day iterative projects with CI gates
De-Sloppify Pattern	Add-on	Quality cleanup after any Implementer step
Ralphinho / RFC-Driven DAG	High	Large features, multi-unit parallel work with merge queue

1. Sequential Pipeline (`claude -p`)

The simplest loop. Break daily development into a sequence of non-interactive claude -p calls. Each call is a focused step with a clear prompt.

Core Insight

If you can't figure out a loop like this, it means you can't even drive the LLM to fix your code in interactive mode.

The claude -p flag runs Claude Code non-interactively with a prompt, exits when done. Chain calls to build a pipeline:

#!/bin/bash
# daily-dev.sh — Sequential pipeline for a feature branch

set -e

# Step 1: Implement the feature
claude -p "Read the spec in docs/auth-spec.md. Implement OAuth2 login in src/auth/. Write tests first (TDD). Do NOT create any new documentation files."

# Step 2: De-sloppify (cleanup pass)
claude -p "Review all files changed by the previous commit. Remove any unnecessary type tests, overly defensive checks, or testing of language features (e.g., testing that TypeScript generics work). Keep real business logic tests. Run the test suite after cleanup."

# Step 3: Verify
claude -p "Run the full build, lint, type check, and test suite. Fix any failures. Do not add new features."

# Step 4: Commit
claude -p "Create a conventional commit for all staged changes. Use 'feat: add OAuth2 login flow' as the message."

Key Design Principles

Each step is isolated — A fresh context window per claude -p call means no context bleed between steps.
Order matters — Steps execute sequentially. Each builds on the filesystem state left by the previous.
Negative instructions are dangerous — Don't say "don't test type systems." Instead, add a separate cleanup step (see De-Sloppify Pattern).
Exit codes propagate — set -e stops the pipeline on failure.

Variations

With model routing:

# Research with Opus (deep reasoning)
claude -p --model opus "Analyze the codebase architecture and write a plan for adding caching..."

# Implement with Sonnet (fast, capable)
claude -p "Implement the caching layer according to the plan in docs/caching-plan.md..."

# Review with Opus (thorough)
claude -p --model opus "Review all changes for security issues, race conditions, and edge cases..."

With environment context:

…

View full docs ↗

// FAQ

What does this skill mainly do?

It provides patterns, architectures, and reference implementations for running Claude Code in autonomous loops, from simple sequential pipelines to RFC-driven multi-agent DAG orchestration. Its focus is helping users choose the right approach for different levels of automation complexity.

What kinds of use cases is it for?

The documentation says it is suitable for unattended development workflows, CI/CD-style continuous development, parallel agent collaboration, context persistence, and adding quality gates and cleanup passes inside loops.

What is the relationship between autonomous-loops and continuous-agent-loop?

The docs state that in v1.8.0, autonomous-loops is retained for one release, while the canonical name is now continuous-agent-loop. New loop guidance should be authored under the newer name.