flow
/flow
Orchestrate a multi-step AOForge workflow by chaining skills. Use when the user wants to invoke a sequence of skills as one ask (e.g., "build and sync to github", "research, plan, then build", "ship and announce"). Triggers on: "ship X to Y", "build and X", "plan and X", "X then Y", "in one go", "as a chain", "all in sequence", "chain", "ship-and-sync", "research-plan-build
- Author
- AO-Cyber-Systems ↗
- Repository
- devflow-claude ↗
- Licence
- MIT
- Last repository change
- 21.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 21.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Orchestrate a multi-step AOForge workflow by chaining skills. Use when the user wants to invoke a sequence of skills as one ask (e.g., "build and sync to github", "research, plan, then build", "ship and announce"). Triggers on: "ship X to Y", "build and X", "plan and X", "X then Y", "in one go", "as a chain", "all in sequence", "chain", "ship-and-sync", "research-plan-build
Triggers from the description
Arguments
/flow <description of the multi-step flow>
Original author description
Orchestrate a multi-step AOForge workflow by chaining skills. Use when the user wants to invoke a sequence of skills as one ask (e.g., "build and sync to github", "research, plan, then build", "ship and announce"). Triggers on: "ship X to Y", "build and X", "plan and X", "X then Y", "in one go", "as a chain", "all in sequence", "chain", "ship-and-sync", "research-plan-build
How it works
SKILL.md has no level-two headings · 95 lines, 672 words
SKILL.md preview
---
name: flow
description: |
Orchestrate a multi-step AOForge workflow by chaining skills. Use when the user wants to invoke a sequence of skills as one ask (e.g., "build and sync to github", "research, plan, then build", "ship and announce").
Triggers on: "ship X to Y", "build and X", "plan and X", "X then Y", "in one go", "as a chain", "all in sequence", "chain", "ship-and-sync", "research-plan-build"
argument-hint: <description of the multi-step flow>
allowed-tools:
- Skill
- Task
- Read
- Bash
- AskUserQuestion
---
<objective>
Orchestrate a multi-skill AOForge workflow as a single user ask. Parse the natural-language description into a sequence of AOForge skill invocations, run them sequentially via the Skill tool (threading objective number / args through), surface intermediate state between steps, and stop on first failure with clear diagnosis.
This skill is the chain-aware front door for combinations like build→gh-sync or research→plan→execute. It is NOT a planner — the user has already named the chain; this skill executes it.
</objective>
<process>
**Step 1: Parse the chain from `$ARGUMENTS`**
Identify two things:
1. **Chain shape** — sequence of skills, in order, with their args.
2. **Threaded args** — the objective number or feature description that flows through each step.
Match the description against the common chains below (case-insensitive). If no named chain matches, derive the sequence from the verbs in the description (e.g., "build and sync to github" → /aoforge:build + /aoforge:gh-sync).
If ambiguous, surface options to the user via `AskUserQuestion` before invoking — do NOT guess.
**Step 2: Display the planned chain**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
AOF ► FLOW
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Chain: {chain-name or derived}
Steps:
1. /aoforge:{skill-1} {args}
2. /aoforge:{skill-2} {args}
...
◆ Starting step 1/N...
```
**Step 3: Invoke each step sequentially via the Skill tool**
For each step:
1. Invoke the skill via `Skill(skill="aoforge:{name}", args="{step-args}")`.
2. After the skill returns, display a transition banner: `✓ Step N/M complete — {short result}` or `✗ Step N/M FAILED — {error}`.
3. On failure, stop the chain. Do NOT proceed to subsequent steps. Surface the failed step's output + suggest a retry/abort path.
4. On success, advance to the next step. Carry through the threaded objective number (most chains share the same objective).
**Step 4: Final summary**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
AOF ► FLOW COMPLETE ✓
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Chain: {chain-name}
Steps: {N}/{N} complete
{Brief per-step result}
```
</process>
<common_chains>
Reference patterns. Match the user's description against these names first; if no match, derive from verbs.
- **build-and-sync** — `/aoforge:build {N}` → `/aoforge:gh-sync {N}`. After building an objective, push state to GitHub: in store mode this flushes the outbox; with the store off it mirrors the objective to its issue.
- **discuss-and-plan** — `/aoforge:discuss-objective {N}` → `/aoforge:plan-objective {N}`. Lock decisions before planning.
- **research-plan-build** — `/aoforge:research-objective {N}` → `/aoforge:plan-objective {N}` → `/aoforge:execute-objective {N}`. Full pipeline from blank slate.
- **debug-and-track** — `/aoforge:debug "{issue}"` → `/aoforge:todo add "{finding}"`. Investigate then capture a follow-up.
- **verify-and-sync** — `/aoforge:verify-work {N}` → `/aoforge:gh-sync {N}`. Re-verify and push verification gaps to GitHub: in store mode this flushes the outbox; with the store off it mirrors the objective to its issue.
- **ship-and-release** — `/aoforge:execute-objective {N}` → `/aoforge:verify-work {N}` → `/aoforge:gh-sync release {tag}`. End-to-end ship with release notes.
- **plan-and-discuss-first** — `/aoforge:discuss-objective {N}` → `/aoforge:research-objective {N}` → `/aoforge:plan-objective {N}`. Lock decisions → research → plan, when an objective is risky or under-specified.
</common_chains>
<rules>
- Never invoke skills in parallel. Chains are strictly sequential — each step's output may inform the next.
- Never invoke `/aoforge:flow` recursively. If a step IS another flow, expand its chain inline before running.
- Never skip steps. If a step fails, stop and surface — do NOT auto-retry beyond what the called skill itself supports.
- Preserve threaded args (objective number, description) across steps — most chains share the same objective; do NOT re-prompt the user for it between steps.
- Honor `disable-model-invocation` on called skills — if any step requires user-typed invocation, stop the chain and tell the user the command to type.
- Do NOT bypass gate-edits or gate-commits. The called skills handle their own gate state via `aof-tools skill-active`.
</rules>
<success_criteria>
- [ ] Chain identified from `$ARGUMENTS` (named or derived)
- [ ] Planned chain displayed to user before execution
- [ ] Each step invoked sequentially via Skill tool
- [ ] Transition banner displayed between steps
- [ ] Chain stops on first failure with clear diagnosis
- [ ] Final summary shown on completion (success or failure)
- [ ] No recursive `/aoforge:flow` invocations
- [ ] Threaded args preserved across steps
</success_criteria>
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · AO-Cyber-Systems/devflow-claude | 92 | MIT |
| lifecycle-innovations-limited/claude-ops | 100 | MIT |
| manhquydev/flow-skill | 100 | MIT |
| simota/agent-skills | 100 | MIT |
| justinedevs/meta-architect | 100 | MIT |
| cofin/flow | 100 | Apache-2.0 |
| panayiotism/claude-harness | 100 | MIT |
| Panza-Labs/floorboss | 96 | Apache-2.0 |
| ohdearquant/lionagi | 95 | Apache-2.0 |
Database snapshot: 13.11.2026 · package version bb38f8de7c79 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 2 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 98skills-workflow
Interactive skills workflow for chaining multiple skills where the output of step i becomes the input of step i-1. Use when you need to: (1) Chain multiple skills together in a specific order, (2) Pass outputs between skills as inputs, (3) Execute complex multi-step workflows… - 100workflow-create
Connects multiple skills into a reusable workflow. It creates a coordinator that runs individual skills in sequence while keeping every skill usable on its own. It can also create missing steps, adopt skills into one family, or update and remove workflows it created. Use when… - 100skill-chain-prompts
Orchestrate multi-skill workflows with prompt-based skill chaining. Define sequential or parallel skill invocations using YAML chain definitions, track progress through chains, and use pre-built chains for development, documentation, and career workflows. Use when coordinating… - 100plan-orchestrate
Read a plan document, decompose it into steps, design a per-step agent chain from the ECC catalogue, and emit ready-to-paste /orchestrate custom prompts. Generative only — never invokes /orchestrate itself. Use when the user has a multi-step plan and wants to drive it through… - 100plan-orchestrate
Read a plan document, decompose it into steps, design a per-step agent chain from the ECC catalogue, and emit ready-to-paste /orchestrate custom prompts. Generative only — never invokes /orchestrate itself. Use when the user has a multi-step plan and wants to drive it through… - 92settings
Configure which agents run, which AI models they use, and how the workflow behaves. Use when the user wants to change AOForge settings or configure workflow behavior. Triggers on: "change settings", "configure AOForge", "update settings", "workflow settings