hive

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Agent Development Workflow

Agent开发工作流

THIS IS AN EXECUTABLE WORKFLOW. DO NOT explore the codebase or read source files. ROUTE to the correct skill IMMEDIATELY.

When this skill is loaded, ALWAYS use the AskUserQuestion tool to present options:

Use AskUserQuestion with these options:
- "Build a new agent" → Then invoke /hive-create
- "Test an existing agent" → Then invoke /hive-test
- "Learn agent concepts" → Then invoke /hive-concepts
- "Optimize agent design" → Then invoke /hive-patterns
- "Set up credentials" → Then invoke /hive-credentials
- "Debug a failing agent" → Then invoke /hive-debugger
- "Other" (please describe what you want to achieve)

DO NOT: Read source files, explore the codebase, search for code, or do any investigation before routing. The sub-skills handle all of that.

Complete Standard Operating Procedure (SOP) for building production-ready goal-driven agents.

这是一个可执行的工作流。请勿探索代码库或阅读源文件。请立即路由到正确的技能。

加载此技能后，请始终使用AskUserQuestion工具来呈现以下选项：

使用AskUserQuestion工具并提供以下选项：
- "构建新Agent" → 然后调用 /hive-create
- "测试现有Agent" → 然后调用 /hive-test
- "学习Agent概念" → 然后调用 /hive-concepts
- "优化Agent设计" → 然后调用 /hive-patterns
- "设置凭据" → 然后调用 /hive-credentials
- "调试故障Agent" → 然后调用 /hive-debugger
- "其他"（请描述您想要实现的目标）

请勿： 在路由前阅读源文件、探索代码库、搜索代码或进行任何调查。这些工作将由子技能处理。

构建生产级目标驱动型Agent的完整标准操作流程（SOP）。

Overview

概述

This workflow orchestrates specialized skills to take you from initial concept to production-ready agent:

Understand Concepts →
```
/hive-concepts
```
(optional)
Build Structure →
```
/hive-create
```
Optimize Design →
```
/hive-patterns
```
(optional)
Setup Credentials →
```
/hive-credentials
```
(if agent uses tools requiring API keys)
Test & Validate →
```
/hive-test
```
Debug Issues →
```
/hive-debugger
```
(if agent fails at runtime)

此工作流编排专业技能，引导您从初始概念到生产级Agent：

理解概念 →
```
/hive-concepts
```
（可选）
构建结构 →
```
/hive-create
```
优化设计 →
```
/hive-patterns
```
（可选）
设置凭据 →
```
/hive-credentials
```
（如果Agent使用需要API密钥的工具）
测试与验证 →
```
/hive-test
```
调试问题 →
```
/hive-debugger
```
（如果Agent在运行时失败）

When to Use This Workflow

何时使用此工作流

Use this meta-skill when:

Starting a new agent from scratch
Unclear which skill to use first
Need end-to-end guidance for agent development
Want consistent, repeatable agent builds

Skip this workflow if:

You only need to test an existing agent → use
```
/hive-test
```
directly
You know exactly which phase you're in → use specific skill directly

在以下场景使用此元技能：

从零开始构建新Agent
不确定首先使用哪种技能
需要Agent开发的端到端指导
想要一致、可重复的Agent构建流程

跳过此工作流的场景：

仅需测试现有Agent → 直接使用
```
/hive-test
```
明确知道当前处于哪个阶段 → 直接使用特定技能

Quick Decision Tree

快速决策树

"Need to understand agent concepts" → hive-concepts
"Build a new agent" → hive-create
"Optimize my agent design" → hive-patterns
"Need client-facing nodes or feedback loops" → hive-patterns
"Set up API keys for my agent" → hive-credentials
"Test my agent" → hive-test
"My agent is failing/stuck/has errors" → hive-debugger
"Not sure what I need" → Read phases below, then decide
"Agent has structure but needs implementation" → See agent directory STATUS.md

"需要理解Agent概念" → hive-concepts
"构建新Agent" → hive-create
"优化我的Agent设计" → hive-patterns
"需要面向客户端的节点或反馈循环" → hive-patterns
"为我的Agent设置API密钥" → hive-credentials
"测试我的Agent" → hive-test
"我的Agent出现故障/卡住/有错误" → hive-debugger
"不确定我需要什么" → 阅读以下阶段说明后再做决定
"Agent已有结构但需要实现" → 查看Agent目录下的STATUS.md

Phase 0: Understand Concepts (Optional)

阶段0：理解概念（可选）

Skill:

/hive-concepts

Input: Questions about agent architecture

技能：

/hive-concepts

输入：关于Agent架构的问题

When to Use

何时使用

First time building an agent
Need to understand node types, edges, goals
Want to validate tool availability
Learning about event loop architecture and client-facing nodes

首次构建Agent
需要理解节点类型、边、目标
想要验证工具可用性
学习事件循环架构和面向客户端的节点

What This Phase Provides

此阶段提供的内容

Architecture overview (Python packages, not JSON)
Core concepts (Goal, Node, Edge, Event Loop, Judges)
Tool discovery and validation procedures
Workflow overview

Skip this phase if you already understand agent fundamentals.

架构概述（Python包，非JSON）
核心概念（目标、节点、边、事件循环、判断器）
工具发现与验证流程
工作流概述

如果您已理解Agent基础概念，请跳过此阶段。

Phase 1: Build Agent Structure

阶段1：构建Agent结构

Skill:

/hive-create

Input: User requirements ("Build an agent that...") or a template to start from

技能：

/hive-create

输入：用户需求（"构建一个能...的Agent"）或用于启动的模板

What This Phase Does

此阶段的工作内容

Creates the complete agent architecture:

Package structure (
```
exports/agent_name/
```
)
Goal with success criteria and constraints
Workflow graph (nodes and edges)
Node specifications
CLI interface
Documentation

创建完整的Agent架构：

包结构（
```
exports/agent_name/
```
）
包含成功标准和约束的目标
工作流图（节点和边）
节点规格
CLI接口
文档

Process

流程

Create package - Directory structure with skeleton files
Define goal - Success criteria and constraints written to agent.py
Design nodes - Each node approved and written incrementally
Connect edges - Workflow graph with conditional routing
Finalize - Agent class, exports, and documentation

创建包 - 包含骨架文件的目录结构
定义目标 - 在agent.py中写入成功标准和约束
设计节点 - 逐步审批并写入每个节点
连接边 - 带有条件路由的工作流图
最终确定 - Agent类、导出内容和文档

Outputs

输出

✅
```
exports/agent_name/
```
package created
✅ Goal defined in agent.py
✅ 3-5 success criteria defined
✅ 1-5 constraints defined
✅ 5-10 nodes specified in nodes/init.py
✅ 8-15 edges connecting workflow
✅ Validated structure (passes
```
uv run python -m agent_name validate
```
)
✅ README.md with usage instructions
✅ CLI commands (info, validate, run, shell)

✅ 创建
```
exports/agent_name/
```
包
✅ 在agent.py中定义目标
✅ 定义3-5条成功标准
✅ 定义1-5条约束
✅ 在nodes/init.py中指定5-10个节点
✅ 连接8-15条边构成工作流
✅ 验证结构（通过
```
uv run python -m agent_name validate
```
）
✅ 包含使用说明的README.md
✅ CLI命令（info、validate、run、shell）

Success Criteria

成功标准

You're ready for Phase 2 when:

Agent structure validates without errors
All nodes and edges are defined
CLI commands work (info, validate)
You see: "Agent complete: exports/agent_name/"

满足以下条件即可进入阶段2：

Agent结构验证无错误
所有节点和边已定义
CLI命令可正常工作（info、validate）
显示："Agent构建完成：exports/agent_name/"

Common Outputs

常见输出结构

The hive-create skill produces:

exports/agent_name/
├── __init__.py          (package exports)
├── __main__.py          (CLI interface)
├── agent.py             (goal, graph, agent class)
├── nodes/__init__.py    (node specifications)
├── config.py            (configuration)
├── implementations.py   (may be created for Python functions)
└── README.md            (documentation)

hive-create技能生成的结构如下：

exports/agent_name/
├── __init__.py          (包导出内容)
├── __main__.py          (CLI接口)
├── agent.py             (目标、图、Agent类)
├── nodes/__init__.py    (节点规格)
├── config.py            (配置)
├── implementations.py   (可为Python函数创建)
└── README.md            (文档)

Next Steps

下一步

If structure complete and validated: → Check

exports/agent_name/STATUS.md

IMPLEMENTATION_GUIDE.md

→ These files explain implementation options → You may need to add Python functions or MCP tools (not covered by current skills)

If want to optimize design: → Proceed to Phase 1.5 (hive-patterns)

If ready to test: → Proceed to Phase 2

如果结构已完成并通过验证： → 查看

exports/agent_name/STATUS.md

或

IMPLEMENTATION_GUIDE.md

→ 这些文件解释了实现选项 → 您可能需要添加Python函数或MCP工具（当前技能未涵盖此部分）

如果想要优化设计： → 进入阶段1.5（hive-patterns）

如果准备好测试： → 进入阶段2

Phase 1.5: Optimize Design (Optional)

阶段1.5：优化设计（可选）

Skill:

/hive-patterns

Input: Completed agent structure

技能：

/hive-patterns

输入：已完成的Agent结构

When to Use

何时使用

Want to add client-facing blocking or feedback edges
Need judge patterns for output validation
Want fan-out/fan-in (parallel execution)
Need error handling patterns
Want best practices guidance

想要添加面向客户端的阻塞或反馈边
需要用于输出验证的判断器模式
想要使用扇出/扇入（并行执行）
需要错误处理模式
想要获取最佳实践指导

What This Phase Provides

此阶段提供的内容

Client-facing interaction patterns
Feedback edge routing with nullable output keys
Judge patterns (implicit, SchemaJudge)
Fan-out/fan-in parallel execution
Context management and spillover patterns
Anti-patterns to avoid

Skip this phase if your agent design is straightforward.

面向客户端的交互模式
带有可空输出键的反馈边路由
判断器模式（隐式、SchemaJudge）
扇出/扇入并行执行
上下文管理与溢出模式
需要避免的反模式

如果您的Agent设计简单直接，请跳过此阶段。

Phase 2: Test & Validate

阶段2：测试与验证

Skill:

/hive-test

Input: Working agent from Phase 1

技能：

/hive-test

输入：阶段1中构建完成的可用Agent

What This Phase Does

此阶段的工作内容

Guides the creation and execution of a comprehensive test suite:

Constraint tests
Success criteria tests
Edge case tests
Integration tests

指导创建并执行全面的测试套件：

约束测试
成功标准测试
边缘情况测试
集成测试

Process

流程

Analyze agent - Read goal, constraints, success criteria
Generate tests - The calling agent writes pytest files in
```
exports/agent_name/tests/
```
using hive-test guidelines and templates
User approval - Review and approve each test
Run evaluation - Execute tests and collect results
Debug failures - Identify and fix issues
Iterate - Repeat until all tests pass

分析Agent - 读取目标、约束、成功标准
生成测试 - 调用代理根据hive-test指南和模板在
```
exports/agent_name/tests/
```
中编写pytest文件
用户审批 - 审核并批准每个测试
运行评估 - 执行测试并收集结果
调试故障 - 识别并修复问题
迭代 - 重复直到所有测试通过

Outputs

输出

✅ Test files in
```
exports/agent_name/tests/
```
✅ Test report with pass/fail metrics
✅ Coverage of all success criteria
✅ Coverage of all constraints
✅ Edge case handling verified

✅ 在
```
exports/agent_name/tests/
```
中生成测试文件
✅ 包含通过/失败指标的测试报告
✅ 覆盖所有成功标准
✅ 覆盖所有约束
✅ 验证边缘情况处理

Success Criteria

成功标准

You're done when:

All tests pass
All success criteria validated
All constraints verified
Agent handles edge cases
Test coverage is comprehensive

满足以下条件即完成此阶段：

所有测试通过
所有成功标准已验证
所有约束已确认
Agent可处理边缘情况
测试覆盖率全面

Next Steps

下一步

Agent ready for:

Production deployment
Integration into larger systems
Documentation and handoff
Continuous monitoring

Agent已准备好：

生产部署
集成到更大的系统中
文档编写与交接
持续监控

Phase Transitions

阶段过渡

From Phase 1 to Phase 2

从阶段1到阶段2

Trigger signals:

"Agent complete: exports/..."
Structure validation passes
README indicates implementation complete

Before proceeding:

Verify agent can be imported:

from exports.agent_name import default_agent

Check if implementation is needed (see STATUS.md or IMPLEMENTATION_GUIDE.md)
Confirm agent executes without import errors

触发信号：

显示"Agent构建完成：exports/..."
结构验证通过
README表明实现已完成

进入前需确认：

验证Agent可被导入：

from exports.agent_name import default_agent

检查是否需要实现（查看STATUS.md或IMPLEMENTATION_GUIDE.md）
确认Agent执行时无导入错误

Skipping Phases

跳过阶段

When to skip Phase 1:

Agent structure already exists
Only need to add tests
Modifying existing agent

When to skip Phase 2:

Prototyping or exploring
Agent not production-bound
Manual testing sufficient

何时跳过阶段1：

Agent结构已存在
仅需添加测试
修改现有Agent

何时跳过阶段2：

原型开发或探索阶段
Agent无需投入生产
手动测试已足够

Common Patterns

常见模式

Pattern 1: Complete New Build (Simple)

模式1：完整新构建（简单版）

User: "Build an agent that monitors files"
→ Use /hive-create
→ Agent structure created
→ Use /hive-test
→ Tests created and passing
→ Done: Production-ready agent

用户："构建一个监控文件的Agent"
→ 使用 /hive-create
→ 完成Agent结构创建
→ 使用 /hive-test
→ 测试创建并通过
→ 完成：生产就绪型Agent

Pattern 1b: Complete New Build (With Learning)

模式1b：完整新构建（含学习环节）

User: "Build an agent (first time)"
→ Use /hive-concepts (understand concepts)
→ Use /hive-create (build structure)
→ Use /hive-patterns (optimize design)
→ Use /hive-test (validate)
→ Done: Production-ready agent

用户："构建一个Agent（首次尝试）"
→ 使用 /hive-concepts（理解概念）
→ 使用 /hive-create（构建结构）
→ 使用 /hive-patterns（优化设计）
→ 使用 /hive-test（验证）
→ 完成：生产就绪型Agent

Pattern 1c: Build from Template

模式1c：基于模板构建

User: "Build an agent based on the deep research template"
→ Use /hive-create
→ Select "From a template" path
→ Pick template, name new agent
→ Review/modify goal, nodes, graph
→ Agent exported with customizations
→ Use /hive-test
→ Done: Customized agent

用户："基于深度研究模板构建一个Agent"
→ 使用 /hive-create
→ 选择"基于模板"路径
→ 选择模板，命名新Agent
→ 审核/修改目标、节点、图
→ 导出包含自定义内容的Agent
→ 使用 /hive-test
→ 完成：自定义Agent

Pattern 2: Test Existing Agent

模式2：测试现有Agent

User: "Test my agent at exports/my_agent"
→ Skip Phase 1
→ Use /hive-test directly
→ Tests created
→ Done: Validated agent

用户："测试我在exports/my_agent路径下的Agent"
→ 跳过阶段1
→ 直接使用 /hive-test
→ 创建测试
→ 完成：已验证Agent

Pattern 3: Iterative Development

模式3：迭代式开发

User: "Build an agent"
→ Use /hive-create (Phase 1)
→ Implementation needed (see STATUS.md)
→ [User implements functions]
→ Use /hive-test (Phase 2)
→ Tests reveal bugs
→ [Fix bugs manually]
→ Re-run tests
→ Done: Working agent

用户："构建一个Agent"
→ 使用 /hive-create（阶段1）
→ 需要实现功能（查看STATUS.md）
→ [用户实现函数]
→ 使用 /hive-test（阶段2）
→ 测试发现Bug
→ [手动修复Bug]
→ 重新运行测试
→ 完成：可用Agent

Pattern 4: Agent with Review Loops and HITL Checkpoints

模式4：含审核循环和HITL检查点的Agent

User: "Build an agent with human review and feedback loops"
→ Use /hive-concepts (learn event loop, client-facing nodes)
→ Use /hive-create (build structure with feedback edges)
→ Use /hive-patterns (implement client-facing + feedback patterns)
→ Use /hive-test (validate review flows and edge routing)
→ Done: Agent with HITL checkpoints and review loops

用户："构建一个包含人工审核和反馈循环的Agent"
→ 使用 /hive-concepts（学习事件循环、面向客户端的节点）
→ 使用 /hive-create（构建带有反馈边的结构）
→ 使用 /hive-patterns（实现面向客户端+反馈模式）
→ 使用 /hive-test（验证审核流程和边路由）
→ 完成：带有HITL检查点和审核循环的Agent

Skill Dependencies

技能依赖关系

hive (meta-skill)
    │
    ├── hive-concepts (foundational)
    │   ├── Architecture concepts (event loop, judges)
    │   ├── Node types (event_loop, function)
    │   ├── Edge routing and priority
    │   ├── Tool discovery procedures
    │   └── Workflow overview
    │
    ├── hive-create (procedural)
    │   ├── Creates package structure
    │   ├── Defines goal
    │   ├── Adds nodes (event_loop, function)
    │   ├── Connects edges with priority routing
    │   ├── Finalizes agent class
    │   └── Requires: hive-concepts
    │
    ├── hive-patterns (reference)
    │   ├── Client-facing interaction patterns
    │   ├── Feedback edges and review loops
    │   ├── Judge patterns (implicit, SchemaJudge)
    │   ├── Fan-out/fan-in parallel execution
    │   └── Context management and anti-patterns
    │
    ├── hive-credentials (utility)
    │   ├── Detects missing credentials
    │   ├── Offers auth method choices (Aden OAuth, direct API key)
    │   ├── Stores securely in ~/.hive/credentials
    │   └── Validates with health checks
    │
    ├── hive-test (validation)
    │   ├── Reads agent goal
    │   ├── Generates tests
    │   ├── Runs evaluation
    │   └── Reports results
    │
    └── hive-debugger (troubleshooting)
        ├── Monitors runtime logs (L1/L2/L3)
        ├── Identifies retry loops, tool failures
        ├── Categorizes issues (10 categories)
        └── Provides fix recommendations

hive（元技能）
    │
    ├── hive-concepts（基础类）
    │   ├── 架构概念（事件循环、判断器）
    │   ├── 节点类型（event_loop、function）
    │   ├── 边路由与优先级
    │   ├── 工具发现流程
    │   └── 工作流概述
    │
    ├── hive-create（流程类）
    │   ├── 创建包结构
    │   ├── 定义目标
    │   ├── 添加节点（event_loop、function）
    │   ├── 连接带有优先级路由的边
    │   ├── 最终确定Agent类
    │   └── 依赖：hive-concepts
    │
    ├── hive-patterns（参考类）
    │   ├── 面向客户端的交互模式
    │   ├── 反馈边与审核循环
    │   ├── 判断器模式（隐式、SchemaJudge）
    │   ├── 扇出/扇入并行执行
    │   └── 上下文管理与反模式
    │
    ├── hive-credentials（工具类）
    │   ├── 检测缺失的凭据
    │   ├── 提供认证方式选择（Aden OAuth、直接API密钥）
    │   ├── 安全存储在 ~/.hive/credentials
    │   └── 通过健康检查验证
    │
    ├── hive-test（验证类）
    │   ├── 读取Agent目标
    │   ├── 生成测试
    │   ├── 运行评估
    │   └── 报告结果
    │
    └── hive-debugger（排障类）
        ├── 监控运行时日志（L1/L2/L3）
        ├── 识别重试循环、工具故障
        ├── 对问题分类（10类）
        └── 提供修复建议

Troubleshooting

故障排除

"Agent structure won't validate"

"Agent结构无法验证"

Check node IDs match between nodes/init.py and agent.py
Verify all edges reference valid node IDs
Ensure entry_node exists in nodes list

Run:

PYTHONPATH=exports uv run python -m agent_name validate

检查nodes/init.py和agent.py中的节点ID是否匹配
验证所有边引用的节点ID均有效
确保entry_node存在于节点列表中

运行：

PYTHONPATH=exports uv run python -m agent_name validate

"Agent has structure but won't run"

"Agent有结构但无法运行"

Check for STATUS.md or IMPLEMENTATION_GUIDE.md in agent directory
Implementation may be needed (Python functions or MCP tools)
This is expected - hive-create creates structure, not implementation
See implementation guide for completion options

检查Agent目录下是否有STATUS.md或IMPLEMENTATION_GUIDE.md
可能需要完成实现工作（Python函数或MCP工具）
这是正常现象 - hive-create仅创建结构，不负责实现
查看实现指南了解完成选项

"Tests are failing"

"测试失败"

Review test output for specific failures
Check agent goal and success criteria
Verify constraints are met
Use
```
/hive-test
```
to debug and iterate
Fix agent code and re-run tests

查看测试输出以定位具体故障
检查Agent目标和成功标准
确认约束已满足
使用
```
/hive-test
```
进行调试和迭代
修复Agent代码后重新运行测试

"Agent is failing at runtime"

"Agent在运行时失败"

Use
```
/hive-debugger
```
to analyze runtime logs
The debugger identifies retry loops, tool failures, and stalled execution
Get actionable fix recommendations with code changes
Monitor the agent in real-time during TUI sessions

使用
```
/hive-debugger
```
分析运行时日志
调试器可识别重试循环、工具故障和停滞执行
提供包含代码修改建议的可操作修复方案
在TUI会话中实时监控Agent

"Not sure which phase I'm in"

"不确定当前处于哪个阶段"

Run these checks:

bash

undefined

运行以下检查：

bash

undefined

Check if agent structure exists

检查Agent结构是否存在

ls exports/my_agent/agent.py

Check if it validates

检查结构是否可验证

PYTHONPATH=exports uv run python -m my_agent validate

Check if tests exist

检查是否存在测试

ls exports/my_agent/tests/

If structure exists and validates → Phase 2 (testing)

如果结构存在且验证通过 → 阶段2（测试）

If structure doesn't exist → Phase 1 (building)

如果结构不存在 → 阶段1（构建）

If tests exist but failing → Debug phase

如果测试存在但失败 → 调试阶段

undefined

undefined

Best Practices

最佳实践

For Phase 1 (Building)

阶段1（构建）的最佳实践

Start with clear requirements - Know what the agent should do
Define success criteria early - Measurable goals drive design
Keep nodes focused - One responsibility per node
Use descriptive names - Node IDs should explain purpose
Validate incrementally - Check structure after each major addition

从清晰的需求开始 - 明确Agent的用途
尽早定义成功标准 - 可衡量的目标驱动设计
保持节点职责单一 - 每个节点只负责一项任务
使用描述性名称 - 节点ID应能说明其用途
逐步验证 - 每次重大修改后检查结构

For Phase 2 (Testing)

阶段2（测试）的最佳实践

Test constraints first - Hard requirements must pass
Mock external dependencies - Use mock mode for LLMs/APIs
Cover edge cases - Test failures, not just success paths
Iterate quickly - Fix one test at a time
Document test patterns - Future tests follow same structure

先测试约束 - 必须通过硬性要求的测试
模拟外部依赖 - 对LLM/API使用模拟模式
覆盖边缘情况 - 不仅测试成功路径，也要测试失败场景
快速迭代 - 一次修复一个测试问题
记录测试模式 - 未来的测试遵循相同结构

General Workflow

通用工作流最佳实践

Use version control - Git commit after each phase
Document decisions - Update README with changes
Keep iterations small - Build → Test → Fix → Repeat
Preserve working states - Tag successful iterations
Learn from failures - Failed tests reveal design issues

使用版本控制 - 每个阶段完成后Git提交
记录决策过程 - 更新README记录变更
保持迭代粒度小 - 构建→测试→修复→重复
保留可用状态 - 为成功的迭代打标签
从失败中学习 - 失败的测试能揭示设计问题

Exit Criteria

退出标准

You're done with the workflow when:

✅ Agent structure validates ✅ All tests pass ✅ Success criteria met ✅ Constraints verified ✅ Documentation complete ✅ Agent ready for deployment

满足以下条件即完成此工作流：

✅ Agent结构验证通过 ✅ 所有测试通过 ✅ 成功标准已满足 ✅ 约束已验证 ✅ 文档完整 ✅ Agent已准备好部署

Additional Resources

额外资源

hive-concepts: See
```
.claude/skills/hive-concepts/SKILL.md
```
hive-create: See
```
.claude/skills/hive-create/SKILL.md
```
hive-patterns: See
```
.claude/skills/hive-patterns/SKILL.md
```
hive-test: See
```
.claude/skills/hive-test/SKILL.md
```
Agent framework docs: See
```
core/README.md
```
Example agents: See
```
exports/
```
directory

hive-concepts：查看
```
.claude/skills/hive-concepts/SKILL.md
```
hive-create：查看
```
.claude/skills/hive-create/SKILL.md
```
hive-patterns：查看
```
.claude/skills/hive-patterns/SKILL.md
```
hive-test：查看
```
.claude/skills/hive-test/SKILL.md
```
Agent框架文档：查看
```
core/README.md
```
示例Agent：查看
```
exports/
```
目录

Summary

总结

This workflow provides a proven path from concept to production-ready agent:

Learn with
```
/hive-concepts
```
→ Understand fundamentals (optional)
Build with
```
/hive-create
```
→ Get validated structure
Optimize with
```
/hive-patterns
```
→ Apply best practices (optional)
Configure with
```
/hive-credentials
```
→ Set up API keys (if needed)
Test with
```
/hive-test
```
→ Get verified functionality
Debug with
```
/hive-debugger
```
→ Fix runtime issues (if needed)

The workflow is flexible - skip phases as needed, iterate freely, and adapt to your specific requirements. The goal is production-ready agents built with consistent, repeatable processes.

此工作流提供了从概念到生产就绪型Agent的成熟路径：

学习使用
```
/hive-concepts
```
→ 理解基础概念（可选）
构建使用
```
/hive-create
```
→ 获取已验证的结构
优化使用
```
/hive-patterns
```
→ 应用最佳实践（可选）
配置使用
```
/hive-credentials
```
→ 设置API密钥（如有需要）
测试使用
```
/hive-test
```
→ 获得已验证的功能
调试使用
```
/hive-debugger
```
→ 修复运行时问题（如有需要）

此工作流灵活可变 - 可根据需要跳过阶段、自由迭代，以适应您的特定需求。目标是通过一致、可重复的流程构建生产就绪型Agent。

Skill Selection Guide

技能选择指南

Choose hive-concepts when:

First time building agents
Need to understand event loop architecture
Validating tool availability
Learning about node types, edges, and judges

Choose hive-create when:

Actually building an agent
Have clear requirements
Ready to write code
Want step-by-step guidance
Want to start from an existing template and customize it

Choose hive-patterns when:

Agent structure complete
Need client-facing nodes or feedback edges
Implementing review loops or fan-out/fan-in
Want judge patterns or context management
Want best practices

Choose hive-test when:

Agent structure complete
Ready to validate functionality
Need comprehensive test coverage
Testing feedback loops, output keys, or fan-out

Choose hive-debugger when:

Agent is failing or stuck at runtime
Seeing retry loops or escalations
Tool calls are failing
Need to understand why a node isn't completing
Want real-time monitoring of agent execution

选择hive-concepts的场景：

首次构建Agent
需要理解事件循环架构
验证工具可用性
学习节点类型、边和判断器

选择hive-create的场景：

实际构建Agent
有清晰的需求
准备好编写代码
需要分步指导
想要基于现有模板进行定制

选择hive-patterns的场景：

Agent结构已完成
需要面向客户端的节点或反馈边
实现审核循环或扇出/扇入
想要使用判断器模式或上下文管理
想要获取最佳实践

选择hive-test的场景：

Agent结构已完成
准备好验证功能
需要全面的测试覆盖率
测试反馈循环、输出键或扇出功能

选择hive-debugger的场景：

Agent在运行时出现故障或卡住
出现重试循环或升级情况
工具调用失败
需要理解节点未完成的原因
想要实时监控Agent执行情况