Agent写作

Name: Agent写作
Author: asteroid-belt

AI 智能已审计

作者仓库星标 48
许可证 MIT
作者更新于实时读取
作者仓库 skulto

流狐档案事实层信息：领域、Agent、信任分、运行环境、权限与网络

领域: AI 智能
兼容 Agent: Claude Code
Cursor
Cline
Codex
Windsurf
Gemini CLI

+20
信任分: 94 / 100 · 已通过审计
作者 / 版本 / 许可: @asteroid-belt · MIT
Token 消耗评级: 中等消耗
接入复杂程度: 需简单配置
是否需要外部 API Key: 不需要
兼容的系统: 未声明（默认跨平台）
底层运行要求: 无特殊要求
文件与系统权限: 只读
允许写入 / 修改
Shell 执行
网络行为: 仅限本地
安装命令数: 26 条

档案由构建时根据 SKILL.md 与安装命令自动衍生，可能与作者实际意图存在差异。

需要注意： 未限定 allowed-tools，默认拥有全部工具权限。

输出预览 autobuild.preview

---
name: autobuild
description: Autonomous single-shot plan execution. Runs entire superplan implementation plans without stoppi…
category: AI 智能
runtime: 无特殊运行时
---

# autobuild 输出预览

## PART A: 任务判断
- 适用问题：提示词、Agent 工作流、模型评估或自动化推理。
- 输入要求：目标材料、限制条件、期望输出和验收方式。
- 证据边界：围绕“Overview / Reference Index - MUST READ When Needed / CLI Arguments”读取原文规则，不把推断写成作者承诺。

## PART B: 执行结果
- **01** 任务判断：确认你的需求是否属于提示词、Agent 工作流、模型评估或自动化推理，并标出输入、限制和预期结果。
- **02** 执行计划：优先按“Overview / Reference Index - MUST READ When Needed / CLI Arguments”拆成步骤，说明每一步会读取什么、修改什么、产出什么。
- **03** 交付结果：给出可复制的命令、文件改动、检查清单或内容草稿，并说明如何继续迭代。
- **04** 风险边界：结合 读取文件、写入/修改文件、执行终端命令、主要在本地完成、通常不需要额外 API Key 给出执行前确认项。

## Running Rules
- 读取文件、写入/修改文件、执行终端命令；主要在本地完成；通常不需要额外 API Key。
- 先小样例验证，再放大到真实任务。
- 交付时同时给结果、检查口径和下一步迭代建议。

SKILL.md SKILL.md

---
name: autobuild
description: Autonomous single-shot plan execution. Runs entire superplan implementation plans without stoppi…
category: AI 智能
source: asteroid-belt/skulto
---

# autobuild

## 什么时候使用
- 把 AI / Agent方向的常用动作沉淀成 Agent 可调用的技能 适合处理AI Agent、提示词、模型评估与自动化推理，核心价值是把输入、判断、执行、验证和交付边界固定下来，避免 Agent 泛泛回答。 把任务拆成可执行、可检查…
- 面向提示词、Agent 工作流、模型评估或自动化推理，优先处理能明确输入、步骤和验收标准的工作。

## 需要提供什么
- 目标材料、目录范围、期望结果和不可改动内容。
- 是否允许联网、执行命令、读写文件或调用外部服务。

## 执行规则
- 围绕「Overview / Reference Index - MUST READ When Needed / CLI Arguments」组织步骤，不把推断写成作者事实。
- 读取文件、写入/修改文件、执行终端命令；主要在本地完成；通常不需要额外 API Key。
- 先跑小样例，确认结果可检查后再扩大任务范围。

## 输出要求
- 给出最终产物、关键证据、验证方式和下一步动作。
- 信息不足时标记 unknown，不编造命令、平台或依赖。

证据边界与执行链路

作者原文负责流程事实；仓库文件负责来源和命令；流狐只补充适用场景、限制和质量判断。

skill "autobuild" {
  输入层     -> 用户目标 + 目标文件 + 禁止范围 + 验收标准
  上下文层   -> Overview / Reference Index - MUST READ When Needed / CLI Arguments
  规则层     -> SKILL.md 触发条件 / 执行顺序 / 输出格式
  运行层     -> 无特殊运行时 | 读取文件、写入/修改文件、执行终端命令 | 主要在本地完成
  安全层     -> 通常不需要额外 API Key + 小任务验证 + diff / 日志复核
  输出层     -> 可复制结果 + 检查清单 + 下一步迭代
}

解读按原文结构重写，命令、链接、术语均保留；右侧可核对作者原始 SKILL.md

先判断是否适合

核心用途：把 AI / Agent方向的常用动作沉淀成 Agent 可调用的技能适合处理AI Agent、提示词、模型评估与自动化推理，核心价值是把输入、判断、执行、验证和交付边界固定下来，避免 Agent 泛泛回答。把任务拆成可执行、可检查、可继续迭代的步骤…
适用任务：更适合 AI Agent、提示词、模型评估与自动化推理，尤其是输入、步骤、验收口径可以反复复用的场景。
不宜硬套：如果任务只有一次性问答、来源材料很少，或需要作者没有说明的命令和外部服务，应先降级为普通对话。

作者设计意图

触发依据：使用时机、上下文收集、输出格式和失败处理共同决定它是否适合当前任务。
来源边界：作者原文负责事实，仓库文件负责命令和文件证据；Fluxly 只补充用途、限制和使用判断。

作者的方法与取舍

执行主线：任务围绕「Overview / Reference Index - MUST READ When Needed / CLI Arguments」组织，把触发条件、必要上下文、执行规则和交付标准连成一条可复核的链路。
设计重点：重点不在重复教程，而在解释作者为什么规定这些步骤、哪些条件不可省略，以及结果偏离时应回到哪一层检查。
使用判断：先确认任务与原文边界一致，再决定是否启用；来源没有说明的命令、平台和依赖保持未知，不由 Fluxly 补写。

边界和复核

依赖条件：通常不需要额外 API Key，适合先用小任务验证触发是否稳定。
权限提醒：会涉及 read / write / shell-exec 权限，执行前要说明可读写范围、命令边界和回退方式。
质量标准：结果应包含明确产物、必要证据和下一步动作；如果只是泛泛解释，需要补充输入和验收条件后重跑。

Autobuild: Autonomous Plan Execution Engine

Execute entire implementation plans in a single pass with zero user intervention. Each phase runs in its own sub-agent, writing state to the filesystem. Context never exhausts because sub-agents are isolated.

Overview

Autobuild is an autonomous execution engine for superplan implementation plans. Unlike superbuild which stops after each phase for user confirmation, autobuild runs everything to completion.

Key Differences from superbuild:

Aspect	superbuild	autobuild
Execution	Phase-by-phase with stops	Continuous until complete
User intervention	Required after each phase	None (fully autonomous)
Context management	Manual compaction	Sub-agents isolate context
State persistence	In conversation	Filesystem (.autobuild/)
Resume capability	Manual	Automatic from state files

Reference Index - MUST READ When Needed

References contain detailed templates and patterns. Read BEFORE you need them.

When	Reference	What You Get
Step 1: Initialize	STATE-FILES.md	State file format, directory structure
Step 3: Execute phases	PHASE-EXECUTION.md	Phase ordering, parallel detection, retry logic
Step 3: Launch sub-agents	SUBAGENT-PROMPTS.md	Exact prompts for phase sub-agents
Step 4: Verify and commit	VERIFICATION.md	Fresh verification, commit handling
Step 5: Handle failures	FAILURE-HANDLING.md	Retry logic, error recovery
Overall flow	ORCHESTRATION.md	Main orchestration loop, completion handling

Also reference superplan documents:

superplan/references/TASK-MICROSTRUCTURE.md - TDD 5-step format per task
superplan/references/TDD-DISCIPLINE.md - TDD enforcement rules
superbuild/references/ENFORCEMENT-GUIDE.md - Quality gate commands by stack

DO NOT SKIP REFERENCES. They contain exact prompts, templates, and formats that are NOT duplicated here.

CLI Arguments

/autobuild <plan-path> [options]

Arguments:
  plan-path           Path to superplan document (required)

Options:
  --commit=<mode>     Git commit behavior (required before execution)
                      - auto: Auto-commit after each phase passes
                      - message-only: Generate messages, user handles git
                      - single: One combined commit at the end

  --resume            Resume from existing state (default if .autobuild/ exists)
  --fresh             Ignore existing state, start from scratch
  --dry-run           Validate plan and show execution order without running

Example invocations:

/autobuild docs/feature-plan.md --commit=auto
/autobuild docs/feature-plan.md --commit=message-only --resume
/autobuild docs/feature-plan.md --commit=single --fresh

Critical Workflow

+-----------------------------------------------------------------------+
|                      AUTOBUILD EXECUTION FLOW                          |
+-----------------------------------------------------------------------+
|                                                                       |
|  1. INITIALIZE       |  Parse args, create .autobuild/, detect stack  |
|         |            |  NO PLAN = EXIT (ask user, then exit if none)  |
|         v            |  NO --commit = STOP (require commit mode)      |
|  2. LOAD STATE       |  Read existing state files if --resume         |
|         |            |  Identify completed phases, pending phases     |
|         v                                                             |
|  3. EXECUTE PHASES   |  For each pending phase (or parallel group):   |
|     |                |                                                |
|     |  3a. Launch sub-agent(s) for phase(s)                           |
|     |      - Sequential phases: one sub-agent at a time               |
|     |      - Parallel phases (2a,2b,2c): concurrent sub-agents        |
|     |                                                                 |
|     |  3b. Sub-agent executes:                                        |
|     |      - Read plan section for its phase                          |
|     |      - Follow TDD micro-structure per task                      |
|     |      - Run quality gates (lint, test, typecheck)                |
|     |      - Update plan checkboxes                                   |
|     |      - Return: status, commit message, files changed            |
|     |                                                                 |
|     |  3c. Write state file for phase                                 |
|         |                                                             |
|         v                                                             |
|  4. VERIFY + COMMIT  |  Re-run quality gates fresh (trust but verify) |
|         |            |  Handle git based on --commit mode              |
|         v                                                             |
|  5. ON FAILURE       |  Retry once, then halt with state preserved    |
|         |            |  Parallel siblings may continue before halt    |
|         v                                                             |
|  6. COMPLETION       |  All phases done, output summary               |
|                      |  State files preserved for audit               |
|                                                                       |
|  =====================================================================|
|  Sub-agents are ISOLATED. Context never exhausts. State is on disk.   |
|  =====================================================================|
|                                                                       |
+-----------------------------------------------------------------------+

Step 1: Initialize

REQUIRED: Plan document and commit mode must be provided.

Argument Validation

AUTOBUILD INITIALIZATION
=========================

Plan: [path]
Commit Mode: [auto|message-only|single]

Validating...

If no plan provided:

ERROR: No plan document provided.

Usage: /autobuild <plan-path> --commit=<mode>

Example: /autobuild docs/feature-plan.md --commit=auto

[EXIT - Cannot proceed without plan]

If no --commit mode specified:

COMMIT MODE REQUIRED
====================

Before I can execute this plan, I need to know how to handle git commits.

Please specify one of:
  --commit=auto         Auto-commit after each successful phase
  --commit=message-only Generate messages, you handle git (recommended)
  --commit=single       One combined commit after all phases complete

Example: /autobuild docs/feature-plan.md --commit=message-only

[WAITING FOR COMMIT MODE]

NO EXCEPTIONS. Do not proceed without explicit commit mode.

Directory Setup

Create .autobuild/ directory structure:

.autobuild/
  config.json           # Execution configuration
  phases/
    phase-0.json        # State file per phase
    phase-1.json
    phase-2a.json
    phase-2b.json
    ...
  logs/
    execution.log       # Overall execution log
    phase-0.log         # Per-phase logs (truncated sub-agent output)
    ...

STOP. Read STATE-FILES.md NOW for complete state file format.

Stack Detection

Detect technology stack to determine quality commands:

STACK DETECTION
===============

Detected:
- Language: TypeScript
- Framework: Express
- Package Manager: pnpm
- Test Framework: Jest
- Linter: ESLint
- Formatter: Prettier

Quality Commands:
- Lint: pnpm run lint
- Format: pnpm run format:check
- Typecheck: pnpm run typecheck
- Test: pnpm test

Stack saved to .autobuild/config.json

Step 2: Load State (Resume Support)

If .autobuild/ exists and --resume (or default):

LOADING EXISTING STATE
======================

Found existing execution state:
- Config: .autobuild/config.json
- Phase files: 6 found

Phase Status:
| Phase | Name | State File | Status |
|-------|------|------------|--------|
| 0 | Bootstrap | phase-0.json | complete |
| 1 | Setup | phase-1.json | complete |
| 2A | Backend | phase-2a.json | failed |
| 2B | Frontend | phase-2b.json | complete |
| 2C | Tests | phase-2c.json | pending |
| 3 | Integration | phase-3.json | pending |

Resuming from Phase 2A (first incomplete)...

If --fresh specified:

FRESH START
===========

--fresh flag detected. Clearing existing state.

Removed: .autobuild/ (6 state files)
Created: .autobuild/ (fresh)

Starting from Phase 0...

Step 3: Execute Phases

Phase Ordering

STOP. Read PHASE-EXECUTION.md NOW for phase ordering rules.

Parse plan to build execution order:

Identify all phases from plan overview table
Build dependency graph from "Depends On" column
Identify parallel groups from "Parallel With" column
Topologically sort for execution order

EXECUTION ORDER
===============

Batch 1 (sequential): Phase 0
Batch 2 (sequential): Phase 1
Batch 3 (parallel): Phase 2A, 2B, 2C
Batch 4 (sequential): Phase 3

Total: 6 phases in 4 batches

Launching Sub-Agents

STOP. Read SUBAGENT-PROMPTS.md NOW for exact sub-agent prompts.

Sequential Phase

EXECUTING PHASE 1: Setup
========================

Launching sub-agent...

[Sub-agent executes autonomously]
[Reads plan section]
[Follows TDD micro-structure]
[Runs quality gates]
[Updates plan checkboxes]
[Returns result]

Sub-agent complete. Processing result...

Parallel Phases

EXECUTING PARALLEL BATCH: 2A, 2B, 2C
=====================================

Launching 3 sub-agents in parallel...

[Sub-agent 2A: Backend API]
[Sub-agent 2B: Frontend UI]
[Sub-agent 2C: Edge Case Tests]

Waiting for all sub-agents to complete...

Results received:
- Phase 2A: complete
- Phase 2B: complete
- Phase 2C: complete

Processing parallel results...

CRITICAL: Use Task tool with run_in_background: true for parallel phases, then collect results with TaskOutput.

Sub-Agent Execution

Each sub-agent:

Reads the plan - Specific section for its phase
Follows TDD - 5-step micro-structure per task
Runs quality gates - Lint, test, typecheck
Updates plan file - Checks off completed tasks
Returns structured result - JSON with status, commit, files

Sub-agent does NOT:

Run git commands (unless --commit=auto in main agent)
Modify other phases
Access conversation history from main agent

Step 4: Verify and Commit

Fresh Verification (Trust But Verify)

STOP. Read VERIFICATION.md NOW for verification requirements.

After sub-agent reports success, VERIFY FRESH in main agent:

VERIFICATION - Phase 2A
=======================

Sub-agent reported: complete

Running fresh verification...

Lint:      pnpm run lint           ... PASS
Format:    pnpm run format:check   ... PASS
Typecheck: pnpm run typecheck      ... PASS
Tests:     pnpm test               ... PASS (47 tests)

All quality gates passed.

If verification fails (sub-agent claimed success but check fails):

VERIFICATION MISMATCH
=====================

Sub-agent claimed success, but fresh verification failed:

Tests: FAIL
  5 tests failed in src/services/auth.test.ts

This indicates a sub-agent error. Treating as phase failure.
Initiating retry...

Commit Handling

Based on --commit mode:

--commit=auto

AUTO-COMMIT - Phase 2A
======================

git add src/api/auth.ts src/api/auth.test.ts
git commit -m "$(cat <<'EOF'
feat(auth): implement JWT token validation

- Add validateToken function
- Add token refresh endpoint
- Add comprehensive test coverage
EOF
)"

Commit created: a1b2c3d

--commit=message-only

COMMIT MESSAGE - Phase 2A
=========================

feat(auth): implement JWT token validation

- Add validateToken function
- Add token refresh endpoint
- Add comprehensive test coverage

Files to commit:
- src/api/auth.ts (CREATE)
- src/api/auth.test.ts (CREATE)

[Message saved to .autobuild/phases/phase-2a.json]
[User handles git operations]

--commit=single

PHASE 2A COMPLETE
=================

Commit message queued for final combined commit.
Continuing to next phase...

State File Update

After each phase (success or failure), update state file:

STATE UPDATED - Phase 2A
========================

File: .autobuild/phases/phase-2a.json
Status: complete
Commit: feat(auth): implement JWT token validation
Files: 2 created, 0 modified
Timestamp: 2025-01-25T10:30:00Z

Step 5: Handle Failures

STOP. Read FAILURE-HANDLING.md NOW for failure handling.

Retry Logic

On phase failure, retry ONCE:

PHASE FAILURE - Phase 2A (Attempt 1/2)
======================================

Sub-agent reported failure:
- Tests failed: 3 failing in auth.test.ts
- Linter: passed
- Typecheck: passed

Initiating retry...

RETRY - Phase 2A (Attempt 2/2)
==============================

Launching fresh sub-agent with error context...

[Sub-agent executes with knowledge of previous failure]

Parallel Sibling Handling

If a parallel phase fails, let siblings complete:

PARALLEL BATCH FAILURE
======================

Phase 2A: FAILED (after retry)
Phase 2B: complete
Phase 2C: running...

Waiting for 2C to complete before halting...

Phase 2C: complete

EXECUTION HALTED
================

Phase 2A failed after retry.
Siblings 2B and 2C completed successfully.

State preserved in .autobuild/
Resume with: /autobuild docs/feature-plan.md --commit=auto --resume

Halt State

AUTOBUILD HALTED
================

Execution stopped due to: Phase 2A failure (tests failing)

Completed phases:
- Phase 0: Bootstrap (complete)
- Phase 1: Setup (complete)
- Phase 2B: Frontend (complete)
- Phase 2C: Tests (complete)

Failed phase:
- Phase 2A: Backend (failed after retry)

Remaining phases:
- Phase 3: Integration (blocked by 2A)

State preserved: .autobuild/

To resume after fixing:
  /autobuild docs/feature-plan.md --commit=auto --resume

To start fresh:
  /autobuild docs/feature-plan.md --commit=auto --fresh

Step 6: Completion

When all phases complete:

+=====================================================================+
|                     AUTOBUILD COMPLETE                               |
+=====================================================================+

Plan: docs/feature-plan.md
Duration: [calculated from timestamps]
Phases: 6/6 complete

Phase Summary:
| Phase | Name | Status | Commit |
|-------|------|--------|--------|
| 0 | Bootstrap | complete | chore(bootstrap): add quality tools |
| 1 | Setup | complete | feat(db): add user schema |
| 2A | Backend | complete | feat(api): implement auth endpoints |
| 2B | Frontend | complete | feat(ui): add login form |
| 2C | Tests | complete | test(auth): add edge case coverage |
| 3 | Integration | complete | feat(auth): wire frontend to backend |

Files Changed: [total count]
Tests Added: [count from test output]
Coverage: [if available]

State preserved: .autobuild/

[Based on --commit mode, output final instructions]

--commit=auto completion

All commits created successfully.
Review with: git log --oneline -6

--commit=message-only completion

PENDING COMMITS
===============

The following commits are ready to create:

1. chore(bootstrap): add quality tools
   git add ... && git commit -m "..."

2. feat(db): add user schema
   git add ... && git commit -m "..."

[etc.]

Full commit commands saved to: .autobuild/commits.sh
Run with: bash .autobuild/commits.sh

--commit=single completion

COMBINED COMMIT MESSAGE
=======================

feat(auth): implement complete authentication system

This commit includes:
- Bootstrap: quality tools configuration
- Database: user schema and migrations
- API: authentication endpoints with JWT
- UI: login and registration forms
- Tests: comprehensive test coverage
- Integration: full e2e authentication flow

Phases completed: 6
Files changed: [count]

Rationalizations to Reject

Excuse	Reality
"Let me run multiple phases in one sub-agent"	NO. Each phase gets its own sub-agent for context isolation
"I'll skip the state file for this phase"	NO. State files enable resume and audit
"The sub-agent passed, no need to verify"	NO. Fresh verification is mandatory
"Let me just continue after failure"	NO. Retry once, then halt
"Sequential phases can run in parallel"	NO. Respect dependency order
"I'll batch the verification at the end"	NO. Verify after each phase
"The plan doesn't specify commit mode"	NO. Require --commit before execution
"Let me auto-commit without being told"	NO. Explicit commit mode required

Red Flags - STOP Immediately

If you catch yourself thinking any of these, STOP:

"Context is getting long, let me combine phases"
"This phase is simple, I can skip the sub-agent"
"The retry failed, but let me try once more"
"Sequential phases don't really depend on each other"
"I'll write the state files at the end"
"Verification is redundant, sub-agents are reliable"
"The user probably wants auto-commit"

All of these = violation of autobuild protocol.

The Iron Rules

Explicit commit mode - Never start without --commit flag
One sub-agent per phase - Context isolation is non-negotiable
State file per phase - Written immediately after completion/failure
Fresh verification - Never trust sub-agent claims alone
Single retry on failure - Then halt with state preserved
Respect dependencies - Sequential means sequential
Parallel means parallel - Launch concurrent sub-agents
Resume from state - Check .autobuild/ before starting
Preserve state on halt - Enable future resume
No user intervention - Fully autonomous execution

Autobuild is rigid by design. The sub-agent isolation prevents context exhaustion. The state files enable resume. The verification ensures quality. Do not rationalize around it.

安装命令

一键复制安装选择包管理器,点击右侧复制,粘贴到终端回车即可

npx skills add asteroid-belt/skulto/.claude/skills/autobuild -y

查看通用安装教程

查看 Skill 原文

兼容工具

Claude Code
Cursor
Cline
Codex
Windsurf
Gemini
OpenCode
Roo Code
AAide
+Augment
GitHub Copilot
OpenClaw
KKiro
Junie
WWarp
Goose
Trae
Kilo Code
OpenHands
Amp
Zencoder
CContinue
AIAider
CodeBuddy
CodeGeeX
Replit Agent

安全审计

94 / 100

已审计

未声明 version。
未限定 allowed-tools，默认拥有全部工具权限。

元信息

来源: github
asteroid-belt/skulto
许可证: MIT
English

分类与标签

分类 AI 智能