flow-marketplace

FLOW — Software Development Lifecycle for Claude Code

An opinionated 6-phase development plugin for Claude Code that enforces plan-first, TDD discipline on every feature. Supports Rails, Python, iOS, Go, and Rust.

Every feature. Same 6 phases. Same order. No shortcuts.

Documentation: benkruger.github.io/flow

---

Why FLOW

Claude Code is powerful, but undisciplined by default. FLOW imposes structure. Not bureaucracy — discipline. DAG decomposition for planning, then TDD execution, then four-step code review, then learnings that compound. Every feature, same order.

---

Three Goals

Unobtrusive

Zero dependencies — pure Markdown skills with a thin Python dispatcher. Prime commits .claude/settings.json and CLAUDE.md as project config — shared permissions and framework conventions. .flow.json and .flow-states/ are git-excluded. During active development, a single gitignored JSON state file exists at .flow-states/<branch>.json. When the feature completes, that file is deleted too. Three commands to set up. One file while you work. Zero when you're done.

Autonomous or Manual

Every skill has two independent axes — commit (show diffs or auto-commit) and continue (prompt before advancing or auto-advance). Start fully manual. Dial up autonomy per skill as comfort grows. Go fully autonomous when you trust the workflow. See Autonomy below.

Safe for Local Env

No containers. No external dependencies. Native tools only — git, gh, your linter, your test runner. Every command is pre-approved in .claude/settings.json so you never see a permission prompt. Worktree isolation protects main — multiple features run in parallel without touching your working branch.

Slack Notifications

Optional thread-per-feature notifications give your team passive awareness of feature progress. Each feature gets one Slack thread — every phase posts a reply, building a narrative from start to merge. Set two env vars, run /flow-prime, done. See Slack Integration.

---

The Workflow

Start → Plan → Code → Code Review → Learn → Complete
  1       2      3         4            5          6

Phase	Command	What happens
1: Start	/flow-start <prompt>	Lock, pull main, bin/ci baseline, upgrade dependencies, bin/ci post-deps, commit to main, unlock, new worktree + PR — ci-fixer sub-agent handles failures
2: Plan	/flow-plan	Reads the start prompt, invokes DAG decompose plugin for dependency analysis, explores codebase, produces ordered tasks with dependency graph
3: Code	/flow-code	Test-first per task, diff review before bin/ci, commit per task, 100% coverage enforced
4: Code Review	/flow-code-review	Four steps — clarity (with convention compliance), correctness (with rule compliance), safety, and parallel agent reviews (context-isolated code review, pre-mortem incident analysis, adversarial test generation launched concurrently)
5: Learn	/flow-learn	Learnings routed to CLAUDE.md, rules, and memory — plugin gaps noted
6: Complete	/flow-complete	Close issues referenced in prompt, PR merged, worktree removed, state file deleted, feature done

---

Guardrails

• bin/ci is the universal gate — must be green before every commit and every phase transition. Recommend keeping guardrails under 2 minutes for tight feedback loops.
• 100% test coverage required — Code phase cannot advance to Code Review without it.
• TDD always — test must fail before implementation is written; test must pass before commit.
• No lint suppression — fix the code, not the linter. No exclusions, no suppression comments.
• Worktree isolation — main is never touched directly; multiple features run in parallel.
• Commit discipline — imperative verb + tl;dr + per-file breakdown, every commit.

---

You Control the Autonomy

Every skill has two independent axes you can tune:

• Commit — whether Claude shows diffs for approval or commits autonomously
• Continue — whether Claude prompts before advancing to the next phase or auto-advances

Start fully manual. As your comfort grows, dial up autonomy per skill. Go fully autonomous when you trust the workflow.

Four preset levels via /flow-prime

Level	What it means
Fully autonomous	All skills auto for both axes — zero prompts
Fully manual	Every diff reviewed, every phase transition confirmed
Recommended	Auto where safe (Code Review), manual where judgment matters (Code, Plan)
Customize	Choose per skill and per axis

Runtime overrides

Any skill invocation accepts --auto or --manual to override the configured setting for that run: