See it in action

A four-act demo of how flow compounds context across days and tasks. The work is silly on purpose — Star Trek bridge starships — so the mechanic is what you watch, not the code.

  1. Act 01

    Capture the work.

    Just talk. flow interviews you for what / why / where / done-when, drafts a structured brief, and opens a dedicated Claude session for the task in a new tab.

  2. Act 02

    Work, then park.

    The session has the brief, the project context, and the knowledge base loaded. You build until you hit a blocker — here, "Kirk needs to review this" — and tell Claude to park it. Status flips to waiting. Tab can close.

  3. Act 03

    Resume and close.

    A day later you say "Kirk signed off." Same session resumes with full memory of where it left off. flow done flips status and triggers the sweep — Claude re-reads the whole transcript and writes durable facts into the knowledge base.

  4. Act 04 — months later

    Months later, a new captain.

    New task: "Picard's the new boss, he wants the starship as an SVG." Brand new session, but it already knows the ship, knows the design choices Kirk approved, knows the project conventions — because the KB carried it. Claude just gets to work.

    That fourth session is what flow is really about.
    Not the first session — the fiftieth.

Why flow

What

flow is a complete task manager — projects, tasks, structured briefs, progress notes, playbooks for recurring work — and a working memory layer that injects all of it into every Claude session automatically. Capture once, work with Claude on it forever.

Why

If you use Claude Code daily, you've felt the ceiling: every session is a new hire. Brilliant, capable, ready to help — but with no memory of yesterday's decisions, last week's migrations, or the half-finished threads in your other tabs. You spend the first ten minutes of every session catching it up.

flow changes the relationship. The first session feels normal. By session ten, Claude knows your codebase quirks, your team, the customer you keep mentioning, and the migration you're three steps into. By session fifty, it's the engineer on your team — not a new hire you re-explain yourself to every morning.

Done when

  • Claude remembers your stack across sessions.
  • Claude remembers your team and the customers you keep mentioning.
  • You stop re-explaining yourself every morning.

Built for power users who want Claude to work with them, not just help them.

How context compounds

Every task feeds the same knowledge base. Every closed task makes the next one smarter.

Knowledge base, Claude session, and task interactions A task brief and notes feed a Claude session via flow do. The session loads context from the knowledge base, writes back to it via live scoop and on-done sweep, and emits progress notes back to the task. ~/.flow/kb/ user · org · products processes · business Task brief.md + updates/*.md Claude session loads brief + kb + notes + repo conventions flow do updates scoop live sweep on done
kb ⇄ session ⇄ task

● Scoop live

During a session the flow skill listens for durable facts you mention — your role, a teammate's name, a product convention — and appends them to the matching kb file on the fly.

● Sweep on flow done

When you close a task, flow spawns a headless Claude pass that re-reads the entire transcript and pulls anything kb-worthy that the live scoop missed.

● Cross-reference

flow transcript <sibling-task> lets a current session read what was decided in a related one — useful when the brief alone doesn't carry enough context.

Net effect: the longer you use flow, the more your knowledge base grows, the less you re-explain yourself.

Playbooks for the work you do on cadence

Some work repeats. Weekly reviews. Daily PR triage. On-call rotations. Customer-meeting prep.

A playbook is a reusable run definition — a markdown brief that describes what a run does. flow run playbook weekly-review snapshots that brief into a fresh task and spawns a new Claude session against it. Every run is reproducible (it executes against a frozen snapshot) and contributes back to the knowledge base on flow done like any other task.

Playbook to snapshot to session A playbook brief is snapshotted into a frozen copy, which becomes a new task, which spawns a new Claude session that executes against the snapshot. Playbook brief.md flow run snapshot (frozen copy) new task kind=playbook_run $ claude definition reproducible task row session
playbook → snapshot → new task → session

Same compounding mechanic. Your weekly review session two months from now will know everything every prior weekly review surfaced.

Install

In any Claude Code session, paste this:

claude 
> Install flow from https://github.com/Facets-cloud/flow

Claude reads the repo, downloads the binary, and runs flow init — which installs the flow skill and registers a SessionStart hook so every future Claude session loads the skill automatically. Then say "let's get to work" and follow along.

Prefer manual install? Expand for curl + chmod + flow init.
bash 
# 1. Download the binary for your Mac.
ARCH=arm64        # Apple Silicon — use amd64 for Intel.

curl -fsSL -o /usr/local/bin/flow \
  "https://github.com/Facets-cloud/flow/releases/latest/download/flow-darwin-${ARCH}"
chmod +x /usr/local/bin/flow
xattr -d com.apple.quarantine /usr/local/bin/flow 2>/dev/null || true

# 2. Initialize — creates ~/.flow/, installs the skill + hook.
flow init