An opinionated 6-phase software development lifecycle for Claude Code. Every feature follows the same phases in the same order. No shortcuts. Supports Rails, Python, iOS, Go, and Rust.
Get StartedClaude Code is powerful, but undisciplined by default. FLOW imposes structure. Not bureaucracy — discipline.
Zero dependencies. Prime commits .claude/settings.json and CLAUDE.md as project config — shared permissions and conventions. .flow.json and .flow-states are git-excluded. One state file while you work — Complete deletes it.
Two axes — commit and continue. Four presets from fully manual to fully autonomous. Per-skill override. You control the autonomy.
No containers. Native tools only — git, gh, linter, test runner. Every command pre-approved during flows — zero permission prompts. Outside flows, Claude Code’s native prompts handle approval. Worktree isolation protects main.
Every feature goes through 6 phases. Each phase must complete before the next one starts. If something was missed, go back. Opus for planning, code, and review. Sonnet for sub-agent reviews.
Every skill has two independent axes you can tune:
/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 |
Any skill invocation accepts --auto or --manual to override the configured setting for that run.
Every commit and every phase transition is gated. No exceptions, no workarounds.
bin/ci is the universal gateMust be green before every commit and every phase transition. Keep guardrails under 2 minutes for tight feedback loops.
Code phase cannot advance to Code Review without it. No gaps, no exclusions.
Test must fail before implementation is written. Test must pass before commit.
Fix the code, not the linter. No exclusions, no suppression comments.
Blocks compound commands (&&, ;, |), shell redirection (>, >>), and file-read commands. Use dedicated tools instead.
Complete fetches main and merges it into the feature branch before squash-merging. Stale branches are updated automatically.
Critical constraints are enforced by hooks, not instructions. If Claude shouldn’t do it, Claude can’t do it — the action is blocked before it executes.
Most AI coding tools forget everything when the session ends. FLOW captures corrections as they happen and routes each learning to the right permanent home in the repo — where it compounds across every future feature.
/flow-note captures it automatically
Process rules and project architecture. “Always run bin/ci before committing.”
Coding anti-patterns and gotchas. “Never use update_column in tests.”
Describe a project in plain language and FLOW decomposes it into a fully linked GitHub issue graph — epic, milestones, sub-issues, blocked-by dependencies, and phase labels. Every issue is filed work-ready with acceptance criteria, file paths, and scope boundaries from real codebase exploration.
/flow-decompose-project add multi-tenant billing
The issue graph feeds directly into /flow-orchestrate below — or pick issues one at a time with /flow-start work on issue #121.
Feed the issue graph into /flow-orchestrate and let FLOW process them overnight. Each issue runs through all 6 phases autonomously. Wake up to a morning report.
Decomposed, filters out in-progress work
/flow-orchestrate builds the execution queue in dependency order
Optional thread-per-feature notifications give your team passive awareness of feature progress without any active monitoring.
Each feature gets one Slack thread. Every phase posts a reply, building a narrative from start to merge.
Start, Plan, Code, Code Review, Learn, Complete — each phase posts its outcome and timing as a thread reply.
Two env vars and one /flow-prime. No webhook servers, no bot infrastructure. Uses Slack’s chat.postMessage API directly.
| Command | Phase | What it does |
|---|---|---|
/flow-start | 1 | Lock, CI baseline on main, upgrade dependencies, CI post-deps, commit to main, create worktree + PR |
/flow-plan | 2 | DAG decompose for dependency analysis, explore codebase, produce ordered tasks |
/flow-code | 3 | TDD task by task, diff review, bin/ci gate before each commit |
/flow-code-review | 4 | Four steps — clarity, correctness, safety, and parallel agent reviews (context-isolated code review, pre-mortem, adversarial testing) |
/flow-learn | 5 | Extract learnings, route to CLAUDE.md and project rules |
/flow-complete | 6 | Merge PR, remove worktree, delete state file |
| Command | What it does |
|---|---|
/flow-prime | One-time project setup — configure permissions and git excludes |
/flow-commit | Full diff review, approved commit message, pull before push |
/flow-status | Current phase, PR link, cumulative time per phase, next step |
/flow-continue | Resume current feature — rebuilds full context on new session |
/flow-note | Capture a correction — auto-invoked when Claude is wrong |
/flow-abort | Abandon feature — close PR, delete branch, remove worktree |
/flow-config | Display current configuration — version, framework, per-skill autonomy |
/flow-issues | Fetch open issues, categorize, prioritize, and display a dashboard. Supports readiness filters |
/flow-create-issue | Explore a design question or decompose a concrete problem, iterate until work-ready, then file it |
/flow-doc-sync | Audit documentation against code behavior — reports drift between what docs say and what code does |
/flow-decompose-project | Decompose a project into a linked GitHub issue graph — epic, milestones, sub-issues, blocked-by dependencies |
/flow-orchestrate | Batch orchestration — process decomposed issues overnight via flow-start --auto |
Monitor every active flow from your terminal. No Claude session needed — flow tui reads state files directly and auto-refreshes every 2 seconds.
Runs standalone in your terminal. Check on flows while Claude is busy, between sessions, or from another machine.
Auto-reads state files every 2 seconds. Phase transitions, code task progress, and log entries appear as they happen.
Open worktrees in your terminal, jump to PRs in your browser, tail session logs, abort features — all from the keyboard.
| Key | Action |
|---|---|
↑ ↓ | Navigate flow list |
← → | Switch tab |
Enter | Open worktree in a new terminal tab |
p | Open PR in browser |
i | Open issue in browser |
l | Show session log |
a | Abort flow (with Y/N confirmation) |
r | Force refresh |
Esc | Back to list view |
q | Quit |
All 6 phase skills, state file infrastructure, session hooks, and reference documentation in one plugin. Marketplace plugin — updates ship automatically.
Step 1: Install in Claude Code
/plugin marketplace add benkruger/flow
/plugin install flow@flow-marketplaceStep 2: Initialize in your project (once per project)
/flow-primeStep 3: Start a feature
/flow-start invoice pdf export