# Flow

> Conduct the full lean-flow loop end-to-end — assess context, ensure a backlog and sprint exist, build through the gates with the right per-task technique, then close with governance. The opt-in conductor: it sequences the standalone skills as stages and enforces the gates/governance, but never auto-approves a human gate. Use when you want the disciplined workflow run for you; use the individual s…

- **Type:** Skill
- **Install:** `agentstack add skill-aldianriski-lean-flow-flow`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [aldianriski](https://agentstack.voostack.com/s/aldianriski)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [aldianriski](https://github.com/aldianriski)
- **Source:** https://github.com/aldianriski/lean-flow/tree/main/skills/flow

## Install

```sh
agentstack add skill-aldianriski-lean-flow-flow
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# flow

The opt-in **conductor** for the lean-flow loop. It drives the standalone skills through the proper
sequence so the discipline *runs* instead of being remembered — **à la carte still works; this is the
conducted path.** It sequences; it never bypasses a gate.

> Every skill stays standalone (nothing requires another). `/flow` is the one component *allowed* to
> depend on the others — conducting them is its whole job. It does not re-implement any stage; it calls them.

## What it conducts

Assess the current state first, then run only the stages whose precondition is unmet — state which you're running and why you're skipping the rest:

1. **Orient** — context missing/stale → `/prime`. Resuming from a handoff? read it first.
2. **Feed** — no open work → `/task-decomposer ""` — **the detailed grill fires here, at intake** (the build gates re-grill only residuals); backlog drifted / noisy → `/triage`.
3. **Plan** — no active sprint but a `ready` backlog exists → `/lean-doc-generator promote` (the governance review fires here).
4. **Build** — `/orchestrator sprint-bulk` through G1 / G2. Route each task by type: new behaviour → `/tdd` · bug → `/diagnose` · hard-to-change → `/refactor-advisor` · a design that must be *felt* → `/prototype` first.
5. **Close** — all DoD ticked → `/lean-doc-generator close` (Retro → §10 buckets), then **`/release-patch` (PATCH) for a fixes-only sprint · MINOR by hand for a feature sprint**.
6. **Continuity** — stopping mid-loop or context budget low → `/handoff`, so the next `/flow` resumes cleanly.

**Pin the target with `/goal`** — set a `/goal` to the active task/sprint's DoD so the conducted run
keeps driving across turns until it's verifiably met; clear it at close. That's the native engine
behind "conduct the loop".

## Conductor, not autopilot

- **Never self-approve a gate.** G1 Scope and G2 Design still need explicit human sign-off — `/flow` pauses at each; it does not wave them through.
- **Halt on first blocker** (BLOCKED / CRITICAL / human `block`) — report and wait.
- **One sprint per stream** — never a second sprint in a stream that already has one; parallel streams (sprint `stream:` frontmatter) each run their own. Single-stream repos: exactly one active sprint, as before.
- The conducted path produces the **same artifacts** as à la carte — it only guarantees the sequence and that the Close governance actually runs.

## Red flags

❌ **Auto-approving G1/G2** — the conductor sequences; the human gates.
❌ **Skipping the Close governance** (Retro / §10) because "the build's done" — that's the part that compounds.
❌ **Re-running a stage whose output already exists** — assess first; skip with a stated reason.
❌ **Conducting when one skill was wanted** — `/flow` is opt-in; a single `/tdd` is not a reason to drive the whole loop.
❌ **Re-implementing a stage inline** — always call the standalone skill, never inline its logic.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [aldianriski](https://github.com/aldianriski)
- **Source:** [aldianriski/lean-flow](https://github.com/aldianriski/lean-flow)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-aldianriski-lean-flow-flow
- Seller: https://agentstack.voostack.com/s/aldianriski
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.