skill-composer

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Skill Composer

Modular workflow builder that chains skills into compound pipelines.

Core principle: Feature Layer + Persona Layer separation, modular addon composition

可将技能串联为复合管道的模块化工作流构建工具。

核心原则：Feature Layer + Persona Layer 分离，模块化插件组合

Rules (Absolute)

规则（强制要求）

Separation of concerns. Every skill in a pipeline has exactly one responsibility. No skill does two things.
Explicit data flow. The output of skill N must be defined input for skill N+1. No implicit state.
Composability over complexity. Prefer chaining 3 simple skills over creating 1 complex one.
Layer isolation. Function layer (what to do) is separate from persona layer (how to communicate).
Fail-forward. If one skill in the pipeline fails, the pipeline should degrade gracefully, not crash.

关注点分离。 管道中的每个技能仅承担一项职责，禁止单个技能同时处理两项任务。
显式数据流。 第N个技能的输出必须明确定义为第N+1个技能的输入，不允许存在隐式状态。
可组合性优先于复杂度。 优先串联3个简单技能，而非创建1个复杂技能。
层级隔离。 功能层（要做什么）与角色层（如何沟通）相互独立。
故障向前兼容。 如果管道中的某一个技能运行失败，管道应优雅降级，而非直接崩溃。

Architecture

架构

Two-Layer Model

两层模型

Inherited from the 기본설정 에드온 system's modular design:

┌─────────────────────────────────────┐
│         Persona Layer               │
│  (tone, style, communication mode)  │
│  e.g., concise / detailed / Korean  │
├─────────────────────────────────────┤
│        Function Layer               │
│  (what the workflow actually does)  │
│  Skill A → Skill B → Skill C       │
└─────────────────────────────────────┘

Function Layer: The pipeline of skills that process the task
Persona Layer: Communication style applied uniformly across all steps

继承自기본설정 에드온系统的模块化设计：

┌─────────────────────────────────────┐
│         Persona Layer               │
│  (tone, style, communication mode)  │
│  e.g., concise / detailed / Korean  │
├─────────────────────────────────────┤
│        Function Layer               │
│  (what the workflow actually does)  │
│  Skill A → Skill B → Skill C       │
└─────────────────────────────────────┘

Function Layer： 处理任务的技能管道
Persona Layer： 所有步骤统一应用的沟通风格

Pipeline Patterns

管道模式

Sequential Pipeline

顺序管道

[Input] → Skill A → Skill B → Skill C → [Output]

Each skill transforms the output of the previous one.

Example: Research → Analyze → Review

yaml

pipeline: research-then-review
steps:
  1: { skill: cross-verified-research, input: "$TOPIC" }
  2: { skill: deep-dive-analyzer, input: "step.1.output" }
  3: { skill: adversarial-review, input: "step.2.output" }

[Input] → Skill A → Skill B → Skill C → [Output]

每个技能对前一个技能的输出进行转换。

示例： 调研→分析→评审

yaml

pipeline: research-then-review
steps:
  1: { skill: cross-verified-research, input: "$TOPIC" }
  2: { skill: deep-dive-analyzer, input: "step.1.output" }
  3: { skill: adversarial-review, input: "step.2.output" }

Fork-Join Pipeline

分叉合并管道

         ┌→ Skill B ─┐
[Input] →│            │→ Merge → [Output]
         └→ Skill C ─┘

Parallel analysis merged into unified output.

Example: Multi-perspective evaluation

yaml

pipeline: multi-perspective
steps:
  1: { skill: creativity-sampler, input: "$DECISION" }
  2a: { skill: adversarial-review, input: "step.1.option_chosen", parallel: true }
  2b: { skill: cross-verified-research, input: "step.1.option_chosen", parallel: true }
  3: { merge: ["step.2a", "step.2b"], format: "comparison-table" }

         ┌→ Skill B ─┐
[Input] →│            │→ Merge → [Output]
         └→ Skill C ─┘

并行分析的结果合并为统一输出。

示例： 多视角评估

yaml

pipeline: multi-perspective
steps:
  1: { skill: creativity-sampler, input: "$DECISION" }
  2a: { skill: adversarial-review, input: "step.1.option_chosen", parallel: true }
  2b: { skill: cross-verified-research, input: "step.1.option_chosen", parallel: true }
  3: { merge: ["step.2a", "step.2b"], format: "comparison-table" }

Iterative Pipeline

迭代管道

[Input] → Skill A → [Check] → Pass? → [Output]
                        ↓ No
                     Skill B → Skill A (retry)

Loop until quality gate passes.

Example: Write-review-refine cycle

yaml

pipeline: quality-loop
steps:
  1: { skill: implement, input: "$TASK" }
  2: { skill: adversarial-review, input: "step.1.output" }
  3: { gate: "step.2.verdict == PASS", retry: 1, max_retries: 2 }

[Input] → Skill A → [Check] → Pass? → [Output]
                        ↓ No
                     Skill B → Skill A (retry)

循环执行直到通过质量门槛。

示例： 编写-评审-优化循环

yaml

pipeline: quality-loop
steps:
  1: { skill: implement, input: "$TASK" }
  2: { skill: adversarial-review, input: "step.1.output" }
  3: { gate: "step.2.verdict == PASS", retry: 1, max_retries: 2 }

Process

操作流程

Step 1: Identify the Goal

步骤1：明确目标

What is the end-to-end outcome?

"Evaluate a technology choice with full rigor"
"Design, implement, and validate a feature"
"Research, decide, and document an architecture decision"

需要达成的端到端结果是什么？

「全面严谨地评估技术选型」
「设计、实现并验证一个功能」
「调研、决策并记录架构选型」

Step 2: Select Skills

步骤2：选择技能

Browse available skills and select those that map to pipeline stages:

Category	Available Skills
Research	`cross-verified-research` , `search-first`
Creativity	`creativity-sampler` , `brainstorming`
Analysis	`deep-dive-analyzer` , `adversarial-review`
Testing	`tiered-test-generator`
Persona	`persona-architect`
Planning	`writing-plans` , `plan`
Review	`code-review` , `full-review`

浏览可用技能，选择匹配管道阶段的能力：

类别	可用技能
调研	`cross-verified-research` , `search-first`
创意创作	`creativity-sampler` , `brainstorming`
分析	`deep-dive-analyzer` , `adversarial-review`
测试	`tiered-test-generator`
角色设定	`persona-architect`
规划	`writing-plans` , `plan`
评审	`code-review` , `full-review`

Step 3: Define Data Flow

步骤3：定义数据流

For each transition between skills, specify:

What data flows from skill N to skill N+1
What format the data should be in
Whether the transition is automatic or requires user approval

针对技能之间的每个流转节点，明确：

哪些数据从第N个技能流转到第N+1个技能
数据需要遵循的格式
流转是自动执行还是需要用户审批

Step 4: Build the Pipeline

步骤4：构建管道

Write the pipeline as a sequence of skill invocations with clear handoff points.

将管道编写为技能调用序列，标注清晰的交接节点。

Output Format

输出格式

markdown

undefined

markdown

undefined

Workflow: [Name]

Workflow: [名称]

Goal

目标

[What this workflow achieves]

[该工作流要实现的效果]

Pipeline

管道

[Step 1] ──→ [Step 2] ──→ [Step 3] ──→ [Output]
  skill        skill        skill

[Step 1] ──→ [Step 2] ──→ [Step 3] ──→ [Output]
  skill        skill        skill

Steps

步骤

Step 1: [Name] (skill: [skill-name])

步骤1：[名称] (skill: [skill-name])

Input: [what it receives]
Action: [what it does]
Output: [what it produces]
Gate: [pass/fail criteria, if any]

输入： [接收的内容]
操作： [执行的动作]
输出： [生成的内容]
门槛： [通过/失败判定标准，若有]

Step 2: [Name] (skill: [skill-name])

步骤2：[名称] (skill: [skill-name])

...

Execution Notes

执行说明

[Any special considerations]
[User approval points]
[Fallback behavior]

undefined

[所有特殊注意事项]
[用户审批节点]
[降级 fallback 行为]

undefined

Pre-Built Workflows

预置工作流

1. Full-Rigor Decision

1. 全严谨决策

creativity-sampler → cross-verified-research → adversarial-review

Generate options → verify facts → stress-test the choice.

creativity-sampler → cross-verified-research → adversarial-review

生成选项→验证事实→对选型进行压力测试。

2. Research-to-Architecture

2. 调研到架构落地

cross-verified-research → creativity-sampler → adversarial-review → architecture ADR

Research the domain → explore approaches → challenge the choice → document the decision.

cross-verified-research → creativity-sampler → adversarial-review → architecture ADR

领域调研→探索方案→挑战选型→记录决策。

3. Implementation Quality Gate

3. 实现质量门槛

implement → tiered-test-generator → adversarial-review → [merge/reject]

Build it → generate tests → review it → gate the merge.

implement → tiered-test-generator → adversarial-review → [merge/reject]

功能开发→生成测试→代码评审→合并门槛校验。

4. Deep Learning Pipeline

4. 深度学习管道

deep-dive-analyzer → tiered-test-generator → [assess gaps] → deep-dive-analyzer (retry)

Analyze deeply → test understanding → fill gaps → iterate.

deep-dive-analyzer → tiered-test-generator → [assess gaps] → deep-dive-analyzer (retry)

深度分析→理解度测试→填补知识缺口→迭代循环。

When to Use

适用场景

Tasks that span multiple concerns (research + decide + validate)
When you want a repeatable, named workflow
When quality gates between steps are needed
When multiple skills should work together in a defined sequence

跨多个领域的任务（调研+决策+验证）
需要可复用、可命名的工作流的场景
需要在步骤间设置质量门槛的场景
需要多个技能按定义序列协同工作的场景

Integration Notes

集成说明

With persona-architect: Design a persona with
```
persona-architect
```
first, then inject it as the Persona Layer of your composed workflow. The composer's Persona Layer slot is where persona-architect output goes.
With cross-verified-research: Most common first step in decision pipelines
With adversarial-review: Most common final step as a quality gate

与persona-architect集成： 先通过
```
persona-architect
```
设计角色，再将其注入到组合工作流的Persona Layer中，composer的Persona Layer槽位可直接导入persona-architect的输出。
与cross-verified-research集成： 决策类管道最常用的首步骤。
与adversarial-review集成： 最常用的末步骤，作为质量门槛。

When NOT to Use

不适用场景

Simple tasks where a single skill suffices
When the workflow is obvious and doesn't need formal definition
One-off tasks that won't be repeated

单个技能即可完成的简单任务
工作流非常清晰，不需要正式定义的场景
不会重复执行的一次性任务