How do I install the Autonomous Loops skill?

Run npx skillmds@latest add kitfunso/autonomous-loops in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

Is Autonomous Loops safe to use?

This skill has not completed SkillMD's automated safety review yet. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Autonomous Loops?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Autonomous Loops free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Autonomous Loops?

kitfunso (@kitfunso) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Autonomous Loops by kitfunso — Agent Skill

Name: Autonomous Loops
Author: kitfunso

Autonomous Loops

Patterns for autonomous agent loops — sequential pipelines, parallel generation, continuous PR loops, and de-sloppify passes. Use when setting up automated workflows, CI/CD agent loops, batch processing with Claude, or multi-agent orchestration. Covers loop architecture from simple sequential to RFC-driven DAG orchestration.

kitfunso ba2ee44 2 files · 3.7 KB Updated Sep 17, 2026

File contents

Autonomous Loop Patterns

Six loop architectures of increasing sophistication. Pick the simplest one that fits.

1. Sequential Pipeline

Each step is isolated (fresh context). Order matters, exit codes propagate.

claude -p "Implement auth module per spec in PLAN.md" && \
claude -p "Review changes, fix issues, run tests" && \
claude -p "Write commit message, commit"

Use when: Simple linear tasks, each step is independent.

2. De-Sloppify Pipeline

Two focused agents beat one constrained agent.

claude -p "Implement feature X with full TDD"
claude -p "Review all changes. Remove: tests of language behavior, console.logs, dead code, over-engineering. Run test suite."

Use when: Any implementation task. Always follow implementation with cleanup.

3. Parallel Generation

Spawn N agents with different creative directions. Each gets an iteration number to prevent duplicates.

for i in $(seq 1 5); do
  claude -p "Iteration $i: Generate solution for X. Be creative, try approach $i." &
done
wait
claude -p "Review all 5 solutions in output/. Pick the best, explain why."

Use when: Creative/exploratory tasks where multiple approaches might work.

4. Continuous PR Loop

Agent runs in a loop: create PR → wait for CI → fix failures → repeat.

Key elements:

SHARED_TASK_NOTES.md bridges context gaps between iterations
Auto-fix failing CI checks
Configurable max-runs, max-cost, completion signals
Merge queue with conflict recovery

Use when: Automated PR workflows, CI-driven development.

5. Spec-Driven DAG Orchestration

Most sophisticated: decompose spec into tiered work units with dependency DAG.

Each unit runs through quality pipeline in isolated worktree
Separate context windows per stage (reviewer ≠ author)
Merge queue with eviction recovery

Use when: Large features with multiple interdependent components.

Decision Flow

Need strict CI/PR control?      → Continuous PR loop
Need RFC decomposition?          → DAG orchestration
Need exploratory parallel gen?   → Parallel generation
Simple linear task?              → Sequential pipeline
Any implementation task?         → Always add de-sloppify pass

Failure Modes to Watch

Loop churn without measurable progress → freeze, audit, reduce scope
Repeated retries with same root cause → investigate, don't retry
Merge queue stalls → check for dependency cycles
Cost drift from unbounded escalation → set --max-budget-usd

---name: autonomous-loopsdescription: Patterns for autonomous agent loops — sequential pipelines, parallel generation, continuous PR loops, and de-sloppify passes. Use when setting up automated workflows, CI/CD agent loops, batch processing with Claude, or multi-agent orchestration. Covers loop architecture from simple sequential to RFC-driven DAG orchestration.---# Autonomous Loop PatternsSix loop architectures of increasing sophistication. Pick the simplest one that fits.## 1. Sequential PipelineEach step is isolated (fresh context). Order matters, exit codes propagate.```bashclaude -p "Implement auth module per spec in PLAN.md" && \claude -p "Review changes, fix issues, run tests" && \claude -p "Write commit message, commit"```**Use when:** Simple linear tasks, each step is independent.## 2. De-Sloppify PipelineTwo focused agents beat one constrained agent.```bashclaude -p "Implement feature X with full TDD"claude -p "Review all changes. Remove: tests of language behavior, console.logs, dead code, over-engineering. Run test suite."```**Use when:** Any implementation task. Always follow implementation with cleanup.## 3. Parallel GenerationSpawn N agents with different creative directions. Each gets an iteration number to prevent duplicates.```bashfor i in $(seq 1 5); do claude -p "Iteration $i: Generate solution for X. Be creative, try approach $i." &donewaitclaude -p "Review all 5 solutions in output/. Pick the best, explain why."```**Use when:** Creative/exploratory tasks where multiple approaches might work.## 4. Continuous PR LoopAgent runs in a loop: create PR → wait for CI → fix failures → repeat.Key elements:- `SHARED_TASK_NOTES.md` bridges context gaps between iterations- Auto-fix failing CI checks- Configurable max-runs, max-cost, completion signals- Merge queue with conflict recovery**Use when:** Automated PR workflows, CI-driven development.## 5. Spec-Driven DAG OrchestrationMost sophisticated: decompose spec into tiered work units with dependency DAG.- Each unit runs through quality pipeline in isolated worktree- Separate context windows per stage (reviewer ≠ author)- Merge queue with eviction recovery**Use when:** Large features with multiple interdependent components.## Decision Flow```Need strict CI/PR control? → Continuous PR loopNeed RFC decomposition? → DAG orchestrationNeed exploratory parallel gen? → Parallel generationSimple linear task? → Sequential pipelineAny implementation task? → Always add de-sloppify pass```## Failure Modes to Watch- Loop churn without measurable progress → freeze, audit, reduce scope- Repeated retries with same root cause → investigate, don't retry- Merge queue stalls → check for dependency cycles- Cost drift from unbounded escalation → set `--max-budget-usd`

Frequently asked questions