[HINT] تحميل مجلد المهارة الكامل بما في ذلك SKILL.md وجميع الملفات المرتبطة
| name | autonomous-loops |
| description | 自主Claude代码循环的模式与架构——从简单的顺序管道到基于RFC的多智能体有向无环图系统。 |
| origin | ECC |
兼容性说明 (v1.8.0):
autonomous-loops保留一个发布周期。 规范的技能名称现在是continuous-agent-loop。新的循环指南应在此处编写，而此技能继续可用以避免破坏现有工作流。
在循环中自主运行 Claude Code 的模式、架构和参考实现。涵盖从简单的 claude -p 管道到完整的 RFC 驱动的多智能体 DAG 编排的一切。
从最简单到最复杂：
| 模式 | 复杂度 | 最适合 |
|---|---|---|
| 顺序管道 | 低 | 日常开发步骤，脚本化工作流 |
| NanoClaw REPL | 低 | 交互式持久会话 |
| 无限智能体循环 | 中 | 并行内容生成，规范驱动的工作 |
| 持续 Claude PR 循环 | 中 | 具有 CI 门的跨天迭代项目 |
| 去草率化模式 | 附加 | 任何实现者步骤后的质量清理 |
| Ralphinho / RFC 驱动的 DAG | 高 | 大型功能，具有合并队列的多单元并行工作 |
claude -p)最简单的循环。 将日常开发分解为一系列非交互式 claude -p 调用。每次调用都是一个具有清晰提示的专注步骤。
如果你无法想出这样的循环，那意味着你甚至无法在交互模式下驱动 LLM 来修复你的代码。
claude -p 标志以非交互方式运行 Claude Code 并附带提示，完成后退出。链式调用来构建管道：
#!/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."
claude -p 调用都是一个新的上下文窗口，意味着步骤之间没有上下文泄露。set -e 在失败时停止管道。使用模型路由：
# 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..."
使用环境上下文：
# Pass context via files, not prompt length
echo "Focus areas: auth module, API rate limiting" > .claude-context.md
claude -p "Read .claude-context.md for priorities. Work through them in order."
rm .claude-context.md
使用 --allowedTools 限制：
# Read-only analysis pass
claude -p --allowedTools "Read,Grep,Glob" "Audit this codebase for security vulnerabilities..."
# Write-only implementation pass
claude -p --allowedTools "Read,Write,Edit,Bash" "Implement the fixes from security-audit.md..."
ECC 内置的持久循环。 一个具有会话感知的 REPL，它使用完整的对话历史同步调用 claude -p。
# Start the default session
node scripts/claw.js
# Named session with skill context
CLAW_SESSION=my-project CLAW_SKILLS=tdd-workflow,security-review node scripts/claw.js
~/.claude/claw/{session}.md 加载对话历史claude -p| 用例 | NanoClaw | 顺序管道 |
|---|---|---|
| 交互式探索 | 是 | 否 |
| 脚本化自动化 | 否 | 是 |
| 会话持久性 | 内置 | 手动 |
| 上下文累积 | 每轮增长 | 每个步骤都是新的 |
| CI/CD 集成 | 差 | 优秀 |
有关完整详情，请参阅 /claw 命令文档。
一个双提示系统，用于编排并行子智能体以进行规范驱动的生成。由 disler 开发（致谢：@disler）。
PROMPT 1（协调器） PROMPT 2（子代理）
┌─────────────────────┐ ┌──────────────────────┐
│ 解析规范文件 │ │ 接收完整上下文 │
│ 扫描输出目录 │ 部署 │ 读取分配编号 │
│ 规划迭代 │────────────│ 严格遵循规范 │
│ 分配创作目录 │ N个代理 │ 生成唯一输出 │
│ 管理批次 │ │ 保存至输出目录 │
└─────────────────────┘ └──────────────────────┘
创建 .claude/commands/infinite.md：
从 $ARGUMENTS 中解析以下参数：
1. spec_file — 规范 Markdown 文件的路径
2. output_dir — 保存迭代结果的目录
3. count — 整数 1-N 或 "infinite"
阶段 1： 读取并深入理解规范。
阶段 2： 列出 output_dir，找到最高的迭代编号。从 N+1 开始。
阶段 3： 规划创意方向 — 每个代理获得一个**不同的**主题/方法。
阶段 4： 并行部署子代理（使用 Task 工具）。每个代理接收：
- 完整的规范文本
- 当前目录快照
- 它们被分配的迭代编号
- 它们独特的创意方向
阶段 5（无限模式）： 以 3-5 个为一波进行循环，直到上下文不足为止。
调用：
/project:infinite specs/component-spec.md src/ 5
/project:infinite specs/component-spec.md src/ infinite
| 数量 | 策略 |
|---|---|
| 1-5 | 所有智能体同时运行 |
| 6-20 | 每批 5 个 |
| 无限 | 3-5 个一波，逐步复杂化 |
不要依赖智能体自我区分。编排器分配给每个智能体一个特定的创意方向和迭代编号。这可以防止并行智能体之间的概念重复。
一个生产级的 shell 脚本，在持续循环中运行 Claude Code，创建 PR，等待 CI，并自动合并。由 AnandChowdhary 创建（致谢：@AnandChowdhary）。
┌─────────────────────────────────────────────────────┐
│ 持续 CLAUDE 迭代 │
│ │
│ 1. 创建分支 (continuous-claude/iteration-N) │
│ 2. 使用增强提示运行 claude -p │
│ 3. (可选) 审查者通过 — 单独的 claude -p │
│ 4. 提交更改 (claude 生成提交信息) │
│ 5. 推送 + 创建 PR (gh pr create) │
│ 6. 等待 CI 检查 (轮询 gh pr checks) │
│ 7. CI 失败？ → 自动修复通过 (claude -p) │
│ 8. 合并 PR (squash/merge/rebase) │
│ 9. 返回 main → 重复 │
│ │
│ 限制条件： --max-runs N | --max-cost $X │
│ --max-duration 2h | 完成信号 │
└─────────────────────────────────────────────────────┘
curl -fsSL https://raw.githubusercontent.com/AnandChowdhary/continuous-claude/HEAD/install.sh | bash
# Basic: 10 iterations
continuous-claude --prompt "Add unit tests for all untested functions" --max-runs 10
# Cost-limited
continuous-claude --prompt "Fix all linter errors" --max-cost 5.00
# Time-boxed
continuous-claude --prompt "Improve test coverage" --max-duration 8h
# With code review pass
continuous-claude \
--prompt "Add authentication feature" \
--max-runs 10 \
--review-prompt "Run npm test && npm run lint, fix any failures"
# Parallel via worktrees
continuous-claude --prompt "Add tests" --max-runs 5 --worktree tests-worker &
continuous-claude --prompt "Refactor code" --max-runs 5 --worktree refactor-worker &
wait
关键创新：一个 SHARED_TASK_NOTES.md 文件在迭代间持久存在：
## 进展
- [x] 已添加认证模块测试（第1轮）
- [x] 已修复令牌刷新中的边界情况（第2轮）
- [ ] 仍需完成：速率限制测试、错误边界测试
## 后续步骤
- 接下来专注于速率限制模块
- 测试中位于 `tests/helpers.ts` 的模拟设置可以复用
Claude 在迭代开始时读取此文件，并在迭代结束时更新它。这弥合了独立 claude -p 调用之间的上下文差距。
当 PR 检查失败时，持续 Claude 会自动：
gh run list 获取失败的运行 IDclaude -pgh run view 检查日志，修复代码，提交，推送--ci-retry-max 次尝试）Claude 可以通过输出一个魔法短语来发出“我完成了”的信号：
continuous-claude \
--prompt "Fix all bugs in the issue tracker" \
--completion-signal "CONTINUOUS_CLAUDE_PROJECT_COMPLETE" \
--completion-threshold 3 # Stops after 3 consecutive signals
连续三次迭代发出完成信号会停止循环，防止在已完成的工作上浪费运行。
| 标志 | 目的 |
|---|---|
--max-runs N | 在 N 次成功迭代后停止 |
--max-cost $X | 在花费 $X 后停止 |
--max-duration 2h | 在时间过去后停止 |
--merge-strategy squash | squash、merge 或 rebase |
--worktree <name> | 通过 git worktrees 并行执行 |
--disable-commits | 试运行模式（无 git 操作） |
--review-prompt "..." | 每次迭代添加审阅者审核 |
--ci-retry-max N | 自动修复 CI 失败（默认：1） |
任何循环的附加模式。 在每个实现者步骤之后添加一个专门的清理/重构步骤。
当你要求 LLM 使用 TDD 实现时，它对“编写测试”的理解过于字面：
typeof x === 'string'）在实现者提示中添加“不要测试类型系统”或“不要添加不必要的检查”会产生下游影响：
与其限制实现者，不如让它彻底。然后添加一个专注的清理智能体：
# Step 1: Implement (let it be thorough)
claude -p "Implement the feature with full TDD. Be thorough with tests."
# Step 2: De-sloppify (separate context, focused cleanup)
claude -p "Review all changes in the working tree. Remove:
- Tests that verify language/framework behavior rather than business logic
- Redundant type checks that the type system already enforces
- Over-defensive error handling for impossible states
- Console.log statements
- Commented-out code
Keep all business logic tests. Run the test suite after cleanup to ensure nothing breaks."
for feature in "${features[@]}"; do
# Implement
claude -p "Implement $feature with TDD."
# De-sloppify
claude -p "Cleanup pass: review changes, remove test/code slop, run tests."
# Verify
claude -p "Run build + lint + tests. Fix any failures."
# Commit
claude -p "Commit with message: feat: add $feature"
done
与其添加具有下游质量影响的否定指令，不如添加一个单独的去草率化步骤。两个专注的智能体胜过一个有约束的智能体。
最复杂的模式。 一个 RFC 驱动的多智能体管道，将规范分解为依赖关系 DAG，通过分层质量管道运行每个单元，并通过智能体驱动的合并队列落地。由 enitrat 创建（致谢：@enitrat）。
RFC/PRD 文档
│
▼
分解（AI）
将 RFC 分解为具有依赖关系 DAG 的工作单元
│
▼
┌──────────────────────────────────────────────────────┐
│ RALPH 循环（最多 3 轮） │
│ │
│ 针对每个 DAG 层级（按依赖关系顺序）： │
│ │
│ ┌── 质量流水线（每个单元并行） ───────┐ │
│ │ 每个单元在其独立的工作树中： │ │
│ │ 研究 → 规划 → 实现 → 测试 → 评审 │ │
│ │ （深度根据复杂度层级变化） │ │
│ └────────────────────────────────────────────────┘ │
│ │
│ ┌── 合并队列 ─────────────────────────────────┐ │
│ │ 变基到主分支 → 运行测试 → 合并或移除 │ │
│ │ 被移除的单元携带冲突上下文重新进入 │ │
│ └────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────┘
AI 读取 RFC 并生成工作单元：
interface WorkUnit {
id: string; // kebab-case identifier
name: string; // Human-readable name
rfcSections: string[]; // Which RFC sections this addresses
description: string; // Detailed description
deps: string[]; // Dependencies (other unit IDs)
acceptance: string[]; // Concrete acceptance criteria
tier: "trivial" | "small" | "medium" | "large";
}
分解规则：
依赖关系 DAG 决定了执行顺序：
Layer 0: [unit-a, unit-b] ← 无依赖，并行运行
Layer 1: [unit-c] ← 依赖于 unit-a
Layer 2: [unit-d, unit-e] ← 依赖于 unit-c
不同的层级获得不同深度的管道：
| 层级 | 管道阶段 |
|---|---|
| trivial | implement → test |
| small | implement → test → code-review |
| medium | research → plan → implement → test → PRD-review + code-review → review-fix |
| large | research → plan → implement → test → PRD-review + code-review → review-fix → final-review |
这可以防止对简单更改进行昂贵的操作，同时确保架构更改得到彻底审查。
每个阶段在其自己的智能体进程中运行，拥有自己的上下文窗口：
| 阶段 | 模型 | 目的 |
|---|---|---|
| Research | Sonnet | 读取代码库 + RFC，生成上下文文档 |
| Plan | Opus | 设计实现步骤 |
| Implement | Codex | 按照计划编写代码 |
| Test | Sonnet | 运行构建 + 测试套件 |
| PRD Review | Sonnet | 规范合规性检查 |
| Code Review | Opus | 质量 + 安全检查 |
| Review Fix | Codex | 处理审阅问题 |
| Final Review | Opus | 质量门（仅限大型层级） |
关键设计： 审阅者从未编写过它要审阅的代码。这消除了作者偏见——这是自我审阅中遗漏问题的最常见原因。
质量管道完成后，单元进入合并队列：
Unit branch
│
├─ 变基到 main 分支
│ └─ 冲突？→ 移除（捕获冲突上下文）
│
├─ 运行构建 + 测试
│ └─ 失败？→ 移除（捕获测试输出）
│
└─ 通过 → 快进合并 main 分支，推送，删除分支
文件重叠智能：
驱逐恢复： 被驱逐时，会捕获完整上下文（冲突文件、差异、测试输出）并反馈给下一个 Ralph 轮次的实现者：
## 合并冲突 — 在下一次推送前解决
您之前的实现与另一个已先推送的单元发生了冲突。
请重构您的更改以避免以下冲突的文件/行。
{完整的排除上下文及差异}
research.contextFilePath ──────────────────→ 方案
plan.implementationSteps ──────────────────→ 实施
implement.{filesCreated, whatWasDone} ─────→ 测试, 审查
test.failingSummary ───────────────────────→ 审查, 实施（下一轮）
reviews.{feedback, issues} ────────────────→ 审查修复 → 实施（下一轮）
final-review.reasoning ────────────────────→ 实施（下一轮）
evictionContext ───────────────────────────→ 实施（合并冲突后）
每个单元在隔离的工作树中运行（使用 jj/Jujutsu，而不是 git）：
/tmp/workflow-wt-{unit-id}/
同一单元的管道阶段共享一个工作树，在 research → plan → implement → test → review 之间保留状态（上下文文件、计划文件、代码更改）。
| 信号 | 使用 Ralphinho | 使用更简单的模式 |
|---|---|---|
| 多个相互依赖的工作单元 | 是 | 否 |
| 需要并行实现 | 是 | 否 |
| 可能出现合并冲突 | 是 | 否（顺序即可） |
| 单文件更改 | 否 | 是（顺序管道） |
| 跨天项目 | 是 | 可能（持续-claude） |
| 规范/RFC 已编写 | 是 | 可能 |
| 对单个事物的快速迭代 | 否 | 是（NanoClaw 或管道） |
该任务是否是一个单一的、专注的变更？
├─ 是 → 顺序管道或NanoClaw
└─ 否 → 是否有书面的规范/RFC？
├─ 有 → 是否需要并行实现？
│ ├─ 是 → Ralphinho（DAG编排）
│ └─ 否 → Continuous Claude（迭代式PR循环）
└─ 否 → 是否需要同一事物的多种变体？
├─ 是 → 无限代理循环（规范驱动生成）
└─ 否 → 顺序管道与去杂乱化
这些模式可以很好地组合：
顺序流水线 + 去草率化 — 最常见的组合。每个实现步骤都进行一次清理。
连续 Claude + 去草率化 — 为每次迭代添加带有去草率化指令的 --review-prompt。
任何循环 + 验证 — 在提交前，使用 ECC 的 /verify 命令或 verification-loop 技能作为关卡。
Ralphinho 在简单循环中的分层方法 — 即使在顺序流水线中，你也可以将简单任务路由到 Haiku，复杂任务路由到 Opus：
# 简单的格式修复
claude -p --model haiku "Fix the import ordering in src/utils.ts"
# 复杂的架构变更
claude -p --model opus "Refactor the auth module to use the strategy pattern"
没有退出条件的无限循环 — 始终设置最大运行次数、最大成本、最大持续时间或完成信号。
迭代之间没有上下文桥接 — 每次 claude -p 调用都从头开始。使用 SHARED_TASK_NOTES.md 或文件系统状态来桥接上下文。
重试相同的失败 — 如果一次迭代失败，不要只是重试。捕获错误上下文并将其提供给下一次尝试。
使用负面指令而非清理过程 — 不要说“不要做 X”。添加一个单独的步骤来移除 X。
所有智能体都在一个上下文窗口中 — 对于复杂的工作流，将关注点分离到不同的智能体进程中。审查者永远不应该是作者。
在并行工作中忽略文件重叠 — 如果两个并行智能体可能编辑同一个文件，你需要一个合并策略（顺序落地、变基或冲突解决）。
| 项目 | 作者 | 链接 |
|---|---|---|
| Ralphinho | enitrat | credit: @enitrat |
| Infinite Agentic Loop | disler | credit: @disler |
| Continuous Claude | AnandChowdhary | credit: @AnandChowdhary |
| NanoClaw | ECC | 此仓库中的 /claw 命令 |
| Verification Loop | ECC | 此仓库中的 skills/verification-loop/ |