flow

Solid

Run the buildflow gated build process from idea to real done-evidence. Walk gated stages (Idea->Research->Scope->PRD->ADR->Contract->Cards->Build->Review->Deploy/Ship->Verify->Retro), each with a honest gate that must pass before advancing. Adapts to project type (web|cli|library|skill). Use when starting or driving a real product build, when the user types /flow, /flow next, /flow card, /flow check, or asks to scope/plan/ship a project through gates. Kill at any gate is a valid outcome.

AI & Automation 2 stars 1 forks Updated today MIT

Install

View on GitHub

Quality Score: 81/100

Stars 20%
16
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
80
License 10%
100
Description 5%
100

Skill Content

# /flow — buildflow gated build harness Idea to a **deployed URL**, not idea to paperwork. You walk gated stages; each has an **output artifact** and a **GATE** — a checklist that must be honestly satisfied before you advance. **Kill at any gate is a valid, honored outcome** (killing a weak idea at Scope is cheap and smart). ``` Idea -> Research -> Scope -> PRD -> ADR -> Contract -> Cards -> Build -> Review -> Deploy -> Verify-live -> Retro |------------------ planning (files in flow/) ------------------| |------- shipping (inside cards/) -------| ``` ## Two-layer harness (this is the core idea) `/flow` is **two layers working together**: 1. **Mechanical layer — `runner/flow.sh`** (deterministic, exit 0/1). It manages the stage/card lifecycle and checks the *cheatable* things: unchecked gate boxes, leftover `[FILL]` placeholders, card status validity, empty done-evidence. Always run it first — its exit code is ground truth, never your own judgment. 2. **Semantic layer — YOU (Claude), via this skill** (quality gatekeeper). The script cannot tell a real competitor quote from a fabricated one, or a grade-laundered C feature from an honest B. **That is your job.** After the script passes, apply the per-stage challenges in `references/gate-rules.md` before you let the operator advance. A gate is only truly passed when **both** layers agree. The script can pass while the content is hollow — catch that. ## Running the mechanical layer From the **project ro...

Details

Author
manhquydev
Repository
manhquydev/flow-skill
Created
1 months ago
Last Updated
today
Language
Shell
License
MIT

Integrates with

Bundled in these plugins

Similar Skills

Semantically similar based on skill content — not just same category

AI & Automation Solid

flow

ONE entrypoint for the whole dev lifecycle — ideate, spec, plan, design, build, review, test, ship, deploy, monitor, retro. Routes to the single canonical command per stage (gstack / GSD / claude-ops) and picks project-mode (GSD phase machine) vs ad-hoc-mode (gstack stateless) from repo `.planning/` state. Bare `/flow` prints the lifecycle map + your current "you are here" position.

20 Updated yesterday
Lifecycle-Innovations-Limited
AI & Automation Listed

prod-flow

Full-rigor staged flow for irreversible or customer-visible work — concept → read-only scout → design → PoC → certify → implement → manual live apply → observe → confirm. Use when a failure would consume a non-refundable consumable (approval, signature, publication, quota) or be visible to a real customer. Enforces packet sealing (GO bound to a packet digest), per-stage receipts, fail-closed gates, and review round limits.

2 Updated 3 days ago
reoring
Testing & QA Listed

flow

Orchestrates the full supermodo development pipeline end-to-end for one task, running each stage in its own subagent so the main context stays small. Eight stages: librarian task intake (grilled), work implementation, optional hunt bug audit, tdd fixes for any bugs found, a mandatory tests gate (suite green + coverage target), refactor, a mandatory post-refactor verify gate, a final librarian docs pass, and commit. Supports entering at a later stage (--from work|hunt|tests|refactor|librarian|commit) and three job sources: an existing docs/work triad, a backlog entry, or a completely new task — with a context-aware "next job" suggestion when none is named. Use when the user wants to run the whole pipeline, "take this task from spec to commit", orchestrate a feature end-to-end, run the full flow (or the flow from a given stage), or drive a task through the complete dev-to-commit process — anything that means coordinating grill → work → hunt → tdd → tests → refactor → librarian → commit rather than a single stag

1 Updated 3 days ago
supermodo