ReleasedAgentic engineering

Flow-Next.

Faster than your agent alone. And better.

Agents generate. Flow-Next proves. Hand it a bug, an idea, a ticket or a slow page and it takes the work all the way to a pull request on GitHub or Bitbucket Cloud or a merge request on GitLab. Name a goal larger than one spec, such as a migration or a framework upgrade, and it builds toward it one reviewed spec at a time until every criterion has evidence. On the same model, the working change comes back in about the time plain Claude Code, or your harness, takes, often less, and a large feature in about half the time. The result is better than the plain agent's before any review runs, and cross-model review and live QA widen the gap to up to 25% better outcomes on large and long-horizon work. Every claim of done carries a receipt, on Claude Code, OpenAI Codex, Factory Droid, Cursor, xAI Grok Build, OpenCode, Muse Code, and Google Antigravity CLI.

Stack
Python 3
Platforms
Claude, Codex, Droid, Cursor, Grok, OpenCode, Muse, Antigravity
Quality gates
Plan, impl, completion
License
MIT
# Claude Code
/plugin marketplace add \
  https://github.com/gmickel/flow-next
/plugin install flow-next
/flow-next:setup

01 / Signal

What people say.

From public issues and PRs on the flow-next repo.

“I am enjoying your version of all these cool new plugins. So far yours has worked the best”
patrickmichalina · GitHub #5
possibilities · PR #95
“really enjoying this project, thanks for making it and making it public (also huge compliments on your website!)”
raydocs · GitHub #4
“it’s been really useful in my workflow.”

Field-hardened in enterprise environments

The engineering methodology built on Flow-Next is coached and run in engineering organisations around the world, from modern monorepos and hundred-repo microservice estates to 30-year-old legacy stacks, across CAD and construction software, proptech, and education. Teams running it report a 3× speed-up on average across the whole R&D organisation, from discovery to merged code, at a higher quality of output: more than 1,000 developers across a private-equity portfolio. An hour-long discovery interview typically produces 8 to 11 specs ready to build, and the edge cases come up in the interview instead of mid-sprint.

02 / Measured

Faster on the work. Better on the result.

I measured 7.0 against plain Claude Code on the same model, over more than 170 full end-to-end runs with each case run several times. Hidden tests the agent never sees check every result, and a blind judge scores the handoff. Speed is time to the working change against the default harness, before any review or QA.

  • 01

    Large feature

    Up to 1.9× faster than the default harness, +25% quality. Plain Claude Code shipped a data-integrity bug in every run. Three cross-model reviewers caught it every time, before the pull request.

  • 02

    Held-out large feature (Rust)

    1.2× faster, +48% quality, on a repository and stack the tuning never touched. After three reviewers and the repo's full test suite, four real bugs were fixed, including a race condition. Flow-Next passed every hidden test; plain Claude Code failed one run in three.

  • 03

    Hard bug

    About 2× faster, +9% quality. It found the real cause and fixed it there, instead of loosening the flaky test.

  • 04

    Simple bug

    1.2× faster, +10% quality, with no review because the fix was small and local. The gain comes from how it works: a failing test first, a fix at the cause, then a check that it works for the user.

  • 05

    Small feature

    1.1 to 1.3× faster, +8% quality. One cross-model reviewer caught a setup check the new option broke, and it was fixed before handoff.

  • 06

    Unattended, through merge

    With --until=merge, a large feature went from spec to a merged pull request with nobody watching and no stops, in about half the time plain Claude Code took to build it.

03 / Problem

Quality fails for predictable reasons.

Model capability is not the bottleneck. Quality fails at the seams: intent that decays, handovers with no record, and a reviewer who is always the same overloaded human.

  • 01

    Output went up. Confidence did not.

    Planning and implementation share one long chat session, so intent decays as the context window fills and the bar drops with it.

  • 02

    Done means something different to everyone.

    Tickets and PR titles carry no acceptance criteria, constraints, or handover state, so every task restarts from what one person remembers.

  • 03

    Review is where delivery stalls.

    The model that wrote the change also blesses it, so the real scrutiny queues behind whichever senior engineer has time.

  • 04

    Shipping decisions rest on a diff.

    Changed lines arrive with no record of what was planned, tested, deferred, or deliberately left alone.

04 / Outcomes

What you get.

Agents generate. Flow-Next proves. What that buys a team, in the order it usually shows up.

  • 01

    Ship more without lowering the bar.

    What the spec requires is what gets implemented. Acceptance criteria are numbered at the spec, carried into every task, and checked again before the spec can close -- so throughput rises because the bar is enforced by machinery, not by whoever still has attention left at 5pm.

  • 02

    Reviews stop being where work waits.

    Review goes by risk. A change to shared state, concurrency, security or data layout, or one across several files, gets three reviewers from another model family before a human sees it; a wording or display change skips review and records why. Your senior engineers then open a pull request written as their briefing. It states why the change exists, walks the review steps in order, and links up to ten must-read files per step, each with its purpose.

  • 03

    Your team's context stops living in three people's heads.

    Specs, decisions, domain terms, how a user reaches each feature, and hard-won lessons accumulate as plain files in the repository as a side-effect of normal work. The next run reads them, and so does whoever joins on Monday.

  • 04

    Climb to autonomy without a leap of faith.

    One dial, from a supervised pair to a loop draining the backlog overnight, and the gates do not change as you climb. Nothing runs on work a person has not blessed, by marking it ready, moving its issue into the ready state, or naming it as a goal. An unattended run lists every decision it made in the pull request and opens it as a draft only when it leaves a call for you. A merge happens only when you authorized it.

  • 05

    Spend the expensive model where it earns its keep.

    Name the roles -- planner, implementer, reviewer, scout -- in your own instructions file, in your own words. The frontier model plans and reviews; a cheaper one does the typing. With a TypeSafe key, workers on routine tasks also think one level less: on three routine tasks, five runs each, they passed every time and cost 20 to 28% less.

  • 06

    Your process outlives your agent.

    The same workflow, the same files, and the same gates on Claude Code, OpenAI Codex, Factory Droid, Cursor, xAI Grok Build, OpenCode, Muse Code, and Google Antigravity CLI, delivering to GitHub, GitLab or Bitbucket Cloud. Changing vendor becomes a tooling decision instead of a re-platforming.

05 / Lifecycle

How the work moves.

From an idea nobody has shaped yet to a merged pull request. Choose the preparation the work needs; keep the configured execution and verification requirements on every route.

  1. 01

    flow · chart · capture · refine

    Say what you have.

    1. 1.1

      Hand /flow-next:flow an idea, a ticket, a pasted bug report or screenshot, a slow page, or a question about the code. It picks the route in seconds, takes a small local fix straight to the change with no spec, runs the stages below for anything larger, and stops at the next decision that is yours. A bug report that does not say where the problem is starts from the matching feature in your feature map. Hand it an idea from Jira Product Discovery and the specs you split from it land in your tracker as child issues under one parent linked back to the idea, so the owner of the idea follows delivery from the idea.

    2. 1.2

      Capture turns the conversation you already had, a prototype, a bug report, or a benchmark result into a durable spec with numbered, source-tagged acceptance criteria, then offers the saved file in your editor.

    3. 1.3

      Too vague to write down? Chart resolves the open decisions one at a time. Refine asks only what would change the build, in one question pass, or runs a read-only research pass that resolves unfamiliar libraries into the spec with a source on every line.

  2. 02

    plan

    Add task boundaries when they help.

    1. 2.1

      Research agents read the code, the docs, prior specs, and what past work here already learned.

    2. 2.2

      Use this optional decomposition when you ask for a task breakdown. A spec can stay whole, even when it spans many files, several repositories or several PRs.

    3. 2.3

      An optional design review can challenge the approach before coding, including when the spec will run without task decomposition. If files the spec cites change after that review and before work starts, the spec goes back to review first, unattended runs included.

  3. 03

    work --no-plan · work

    Build it, then check it like a user.

    1. 3.1

      For a strong, ready, cohesive spec and a capable agent, start with Flow-Next work --no-plan. A spec with one task is built right in your conversation; fresh-context workers and the parallel scheduler run when a spec has several tasks, or when you route a task to a chosen model.

    2. 3.2

      It writes the failing test first, fixes the cause and any sibling case the same cause breaks, then runs the change the way a user meets it. A bug fix first checks whether someone already fixed it, confirms the cause with runtime evidence, bisects to the change that introduced it when a known-good revision exists, and, when the state behind the failure should never exist, fixes the code that produced it rather than guarding where it surfaced. The proof is the same reproduction failing on the base and passing on the head, run through the command, request or screen the bug was reported from.

    3. 3.3

      Done is not a sentence: the task records the tests that ran, the commits, and the choices it made and why, and the handoff marks each claim measured, inferred or a guess.

  4. 04

    impl-review · spec-completion-review

    Prove it, then prove nothing was missed.

    1. 4.1

      Review goes by risk, the same way on every reviewer: three reviewers from another model family for shared state, concurrency, security, data layout or a multi-file change, one for a small local fix, none for wording or display. A finding blocks only with a concrete failing scenario.

    2. 4.2

      When you are there, you get the result first and the review runs in the background; after the fixes the same reviewer looks only at what changed, and anything left is your call. Unattended, the loop runs until the reviewer signs off.

    3. 4.3

      Before a multi-task spec can close, a completion gate checks every acceptance criterion against the code -- catching the gaps that per-task review structurally cannot see. On a one-task spec, the review checks your standing project criteria too.

  5. 05

    make-pr · resolve-pr

    A pull request written for its reviewer.

    1. 5.1

      The body opens with why the change exists, then walks the review steps in order. Each step says what to check and links up to ten must-read files, each with its purpose and the requirement it serves.

    2. 5.2

      One line counts every other file, and the verification checklist ticks only what passed. A failed or unverified gate stays unticked with its note. A bug fix also shows why the bug happened and how the fix was proven, and any step that did not happen says so.

    3. 5.3

      The pull request opens ready for review, or as a draft when a spec question, unfinished work, an open QA finding or a call for you is left. When review comments land, resolve-pr triages, fixes, answers, and resolves them in one bounded pass. On a GitLab origin, gitlab.com or self-managed, the same body opens a merge request, and resolve-pr works through its discussions and notes. On Bitbucket Cloud it opens a pull request, and resolve-pr answers and resolves its comments.

  6. 06

    flow --auto · flow --goal · land

    Or let the loop drive.

    1. 6.1

      Mark a spec ready, or drag the issue to your ready state, and one /flow-next:flow --auto invocation carries it hop after hop to a pull request. It never stops to ask, keeps fixing until the reviewer signs off, and writes every decision it made into the pull request. An issue with no spec behind it starts the same way with --from-issue: the spec is captured from the issue, its design reviewed against it, and an unclear issue gets its questions on the issue instead.

    2. 6.2

      For an outcome larger than one spec, /flow-next:flow --goal measures the goal, splits it into child specs and builds them, and repeats until every criterion has evidence. The goal spec says how strict each child’s path is, from straight commits for a prototype to a reviewed pull request per child. Children land on an integration branch; one final, fully reviewed pull request takes the goal to your default branch.

    3. 6.3

      Land takes the one pull request you name. Each run resolves review threads, makes one CI fix or one flake rerun (it stops rather than delete the pull request's own failing test to get green), catches the branch up, and merges only when you authorized the merge in the session. On GitLab it squash-merges the merge request once the pipeline for its current head has passed and GitLab's own merge check allows it, and on Bitbucket Cloud once every build on the head has passed and Bitbucket's merge checks allow it.

    4. 6.4

      Same gates as an interactive run. Autonomy suppresses questions, never reviews.

Same guarantees whether you ship one task or the whole spec.

/flow-next:flow reads what you hand it and runs the route, and flow --explain prints that route and writes nothing. Every stage is also a skill you can call by name. For a ready, cohesive spec and a capable agent, use Flow-Next work --no-plan. Add task planning when delivery needs separate boundaries. Beside these routes sit ranked idea generation, a strategy anchor, a readiness assessment for a codebase, a memory audit and glossary upkeep, one-screen visual digests of a spec or a diff, and a ten-rule prose contract that every pull-request body, spec, and tracker comment is drafted against. Every one also runs from plain language, so there is nothing to memorize.

The full command catalog →

06 / Review

How work gets proven.

Evidence is self-run; the verdict never is. The model that wrote the change runs the tests and never issues its own approval. A different family reads it, as many reviewers as the risk calls for, and introduced findings go back to the author. Same-model self-review is a blind mirror.

Cross-platform

OpenAI Codex CLI

GPT-family frontier reviews. Runs on Linux, macOS, Windows.

Cross-platform

GitHub Copilot CLI

GPT and Claude reviewer models via Copilot. Native org integration.

Cross-platform

Cursor

One subscription, reviewer models from several families. Pin any of them per project or per task.

Cross-platform

Claude Code CLI

A Claude-family review from Codex, Cursor, Grok Build, Droid, OpenCode, or Muse Code, with the same receipt, round counter, and fix loop.

Any model family

Review command

A wrapper you set on your own machine puts Gemini, Grok, Kimi, DeepSeek or your organisation's own reviewer behind every review. Flow-Next keeps the prompt, rounds, verdict and receipt.

No extra CLI

Host

A fresh-context reviewer inside the harness you are already running, pinned to a different model family than the writer.

Every reviewer runs the same panel: one reviewer for a small change in one area, three for anything larger (correctness, contracts, integration), merged into one fix pass, so switching reviewer never changes how closely a change is checked. Pick one for the project or one for a single run. When you are there, plans and implementations get one review and one re-review of the fixes, and what is left is your call. Unattended, they loop until the reviewer signs off. Each round leaves a receipt carrying the verdict, the reviewer’s confidence, and which problems the change introduced rather than inherited. Only the introduced ones count against it.

How work gets proven →

07 / Flexibility

A menu, not a rail.

Opinionated rails for newcomers, composable primitives for experts -- and nothing to memorize: every step runs from plain language, every option has a plain-language equivalent. Skip stages, reorder them, prompt into any step, one-shot the whole chain, route a different model per step, or compose beyond the pipeline (research or test first, then let the result write the spec). Every route keeps the same execution, evidence, and review contracts.

  • 01

    Smallest sufficient workflow

    Start with a complete spec. When it is ready and cohesive and the agent is capable, execute it through Flow-Next work --no-plan. Add decomposition only when you want a task breakdown; resolve open product and authority choices through a refine pass.

  • 02

    Prompt into any stage

    Every step takes plain-language steering: skip the research pass, run two disjoint tasks in parallel, pick a specific reviewer. Parameters set the floor; prompting steers above it.

  • 03

    Route models per step

    Plan on your best model, implement on a cheaper one, review with a different family than the writer. Named once in your own instructions file or said in the prompt for a single run. Cross-model review by construction: uncorrelated blind spots.

  • 04

    Same gates on every route

    Both routes retain the full spec, configured implementation review, tests, coverage, completion policy, and opt-in live QA. Skipping task decomposition changes the preparation, while the work still runs through Flow-Next with evidence required at done.

# hand it anything and read the route before it runs
/flow-next:flow --explain "the /reports page takes four seconds"

# one-shot the whole chain
"plan, work, and make-pr for fn-12 -- no questions"

# parallelize disjoint tasks from one spec
"run fn-12.2 and fn-12.3 in parallel -- disjoint files"

# ready, cohesive spec with a capable agent
/flow-next:work fn-12 --no-plan

# pick the reviewer for one run
"review fn-12.1 with cursor"

08 / Autonomy

Autonomous loops. Board in, merged pull requests out.

One dial, from a supervised pair to a loop draining the backlog overnight, and the gates do not change as you climb. The build loop takes a ready spec to a pull request without asking, and a tracker issue moved into your ready state can start it with no spec written first. A goal run works toward an outcome larger than one spec, one child spec at a time, until every criterion it measures has recorded evidence, and reaches your default branch through one final reviewed pull request. The ship loop takes the one pull request or GitLab merge request you name through review threads and CI, and merges it only with authorization given in the session.

# bless work (or drag the issue to your board's ready state)
flowctl spec ready fn-12

# the build loop: ready spec -> PR, in one invocation
/flow-next:flow --auto --review=codex

# or one hop per interval, from a scheduled loop
/loop 30m /flow-next:flow --auto --tick

# the ship loop: the PR or GitLab MR you name -> merged
/loop 15m /flow-next:land 123

# or one spec from ready through an authorized merge
/flow-next:flow --auto fn-12 --until=merge

# or an issue moved to ready, no spec yet: capture, review, build, merge
/flow-next:flow --auto --from-issue ENG-123 --until=merge

# or an outcome larger than one spec: measure, build the next spec, repeat
/flow-next:flow --goal docs/migration/target-spec.md --until=merge
  • 01

    The build loop

    One invocation selects a ready spec and carries it hop after hop to a pull request. It never asks: every default it picks, finding it declines and review it skips goes into a Decisions list in the pull request. It records each hop on disk, so an interrupted run resumes from that record, and it ends with one machine-readable verdict line. Two hops without progress and the spec goes back to a person.

  • 02

    The ship loop

    You name one pull request. Each run reads it, makes at most one repair (review threads, one CI fix, or a branch catch-up), and prints one verdict line. Land merges when every check is green, no thread is open, and you authorized the merge in the current session. It keeps no state between runs. An unattended merge waits 10 minutes after the last push so review bots can post. On GitLab it squash-merges with the head SHA pinned, so a push made in the meantime fails the merge, and it never turns on auto-merge; a step GitLab has no equivalent for, such as rerunning a job, stops for a person.

  • 03

    From a tracker issue

    Someone moves an issue into your ready state, and one invocation takes it to a merged pull request with nobody capturing a spec first. The run captures the spec from the issue's own words and invents no acceptance criterion, holds it to a bar for unattended work (small, fully known, one pull request, every criterion testable and traceable to the issue), reviews the spec's design against the issue, and reviews every task on your configured reviewer, whatever its size. An issue that misses the bar gets its questions posted on the issue and leaves the ready state; answering in a comment or editing the issue, then moving it back, starts the next run. On Linear, a clear issue went from Todo to a merged pull request and Done in one invocation.

  • 04

    Toward an outcome

    For work where you know the outcome and how to check it, but not the specs that get there: a port or migration to a new stack, a large codebase upgraded to a newer framework version, a PRD worked down to shipped changes, a release bar. The goal is an ordinary spec whose acceptance criteria are the bar. Each run measures them, decides how to split the work into child specs, and builds each with the same routing, reviews and gates as a spec you wrote, as strict as the goal spec asks: a prototype can commit each feature straight with one review at the end, and a gated release keeps a pull request and review per child. Children always land on an integration branch, so your default branch never ships a half-finished migration, and the goal reaches it through one final pull request with a full review. A goal log in the goal spec carries every measurement, decision and open question across sessions, so a goal that takes days resumes where it stopped, and the run ends GOAL_MET only on recorded evidence for every criterion.

  • 05

    Consent at the edges

    No loop touches work you have not marked ready or named as a goal. The ready flag, or your tracker board, is the entry gate. Naming a goal covers only the child specs the run writes for it, and the run never edits the goal's criteria or boundaries. A call only you can make goes into the pull request as an open item, on a draft, instead of stopping the run. Merge consent is separate. You give it in the session, and environment variables, repository files, and pull-request text carry none.

  • 06

    It fails loudly or not at all

    The rules an unattended run follows were hardened against real overnight failures: an agent may never edit a test to make it pass, a suspiciously fast green gets its log read before anything is recorded, and cleanup commits only what the run itself produced. A run keeps to the spec you named, stops at blocked work, and refuses a review receipt whose verdict contradicts the review it records. When a guard is missing the evidence it checks, the run stops.

Quality gates are identical to interactive runs -- autonomy suppresses questions, never reviews. Climbing the dial changes how much you watch, not how much gets verified.

09 / Compounding

It gets better while you use it.

Your team's context stops living in three people's heads. Four surfaces in the repository grow as side-effects of the work you already run -- there is no refresh command to remember, because improvement that depends on remembering an extra command does not happen.

  • 01

    Memory

    Categorized bug and knowledge entries, written at the moment a review round turns a failure into a fix. The next task touching that module reads them first. A recurring lesson graduates into an enforced gate rather than staying advice.

  • 02

    Glossary and decisions

    The terms your domain uses and the choices that were hard to reverse, at the repository root where they survive deleting everything else. Superseding a decision keeps the trail of why; nothing is silently dropped.

  • 03

    Strategy

    A repo-root anchor -- target problem, approach, who it is for, metrics, tracks -- that planning and idea generation read as grounding. Drift is flagged for you, never auto-resolved, because that call is yours.

  • 04

    Feature map

    How a user reaches each feature, how an agent drives it, and the traps that waste a run. Every route is proven by a live drive, and a change that alters a route updates its entry in the same pull request. Every stage that drives the running app, from bug intake to QA and performance checks, starts from the matching feature instead of searching the app.

All four are plain files in your repository, read by the next run and by the teammate who joins on Monday. The upkeep pass flags, supersedes, or consolidates entries -- it never drops one in silence.

How it compounds →

10 / Teams

From solo workflow to team methodology.

A shared spec, optional task planning, and evidence through delivery. The conversations that didn't happen become the artefacts that did.

  • 01

    The spec, business layer

    A product owner fills the goal, the boundaries, the success measures, and what explicitly must not be built, in an interview that keeps to product decisions in plain words. Technical questions are handed to the tech lead instead of asked of the product owner.

  • 02

    The spec, technical layer

    The tech lead completes the same file, having read the business sections first and cited them, so technical answers cannot quietly contradict a business constraint. Criteria are added across passes, never renumbered.

  • 03

    The implementation plan, when useful

    Optional task boundaries when you ask for a plan, with acceptance criteria assigned to each. A ready spec otherwise runs whole through Flow-Next work --no-plan.

  • 04

    The working implementation

    Every task hands back the commits, the tests that ran, the files touched, and a written account of the choices made, each claim marked measured, inferred or a guess. That account is what the pull-request body is built from later.

  • 05

    The cross-model review

    A model from a different family reads the change and returns a verdict, its confidence, and a separation of introduced from pre-existing problems. The receipt is a file in the repository, not a message in a transcript.

  • 06

    The pull request

    One body, on a GitHub or Bitbucket Cloud pull request or a GitLab merge request, written as a briefing for the reviewer. It carries why the change exists, the review steps in order, the must-read files as links, requirement coverage, and a checklist that ticks only what passed. A bug fix adds the confirmed cause, the introducing commit, and the base and head results. An unattended run adds its Decisions list.

The team guide covers the rest: reviewing a spec as a pull request before any code exists, several developers working one spec in parallel, and a Week 1 / Month 1 / Quarter 1 adoption ladder that starts with a spec and Flow-Next work, adding task planning when useful.

The team workflow guide →

Rolling this out with help: Agentic SDLC →

11 / Optional

It grows with you.

Off by default, and absent costs nothing. Turn one on when the team has a reason, not because it exists.

  • Live QA

    Drives the running app like an unforgiving real user, with scenarios taken straight from the spec, and is forbidden from passing by reading source. After a fix, it re-checks only what the fix could have touched and carries the earlier results for the rest: on a small storefront app that made the pass 10 to 25% faster, and it caught the planted bug in every run. It augments staging and manual QA rather than replacing them.

  • Feature map

    A committed record of how a user reaches each feature and which traps waste a verification run, every route proven by a live drive. Normal work keeps it current: a change that moves a page or renames a button updates the map in the same pull request, and Flow tells you when a full maintain pass is due. Every stage that drives your running app starts from it: performance measurements, bug-fix proofs, QA, and the live checks a pull request reports. On a fixture app, tasks that did not say where their target was took about 40% fewer turns (66 runs), with success no lower.

  • Tracker sync

    Mirror a spec into Linear, GitHub, GitLab, or Jira and reconcile body, status, and comments both ways. A merged pull request or merge request moves the issue to Done. The spec stays the source of truth, and a team that keeps it as the only record can make the issue body follow it; the board can still be where your team lives. Ask flow to triage the open issues no spec covers and it proposes one action per issue in a single table, for you to confirm once. The Jira or Linear token can come from your own secret store through one configured command, so nobody exports it in their shell, and a command whose path belongs to one machine can sit in that machine's environment instead of the committed config. Name a parent while capturing and the issue is created under it on Jira Cloud, Linear or GitLab; GitHub and Jira Data Center/Server refuse a parent. On Jira Cloud, attended flow can start from a Jira Product Discovery idea and file the specs you choose as child issues under one parent linked back to the idea; nothing else is written to the idea.

  • Regulated environments

    For teams that must show what was required, built, tested, reviewed and approved. Turn on committed evidence per spec, spec approval by pull request, or both, and flowctl trace prints a per-requirement matrix that flags every gap. It supports and feeds your validation, and changes nothing until you set it.

  • Judge

    With a TypeSafe API key set, a few narrow questions get a fast typed answer: a hint at the kind of a fork the agent already found, the order of memory search hits, and the tier for a task, which also sets how hard the worker thinks, one level below or above the default when the call is clear. Routing and the QA gate never ask it, so a run with a key and one without take the same route. Review, QA, and merge gates keep their own authority.

  • Implementation offload

    Hand the token-heavy typing to a second, cheaper agent, such as Antigravity CLI, while your session keeps orchestration, judgment, and the verdict. You state it in a sentence; there is no subsystem to configure.

12 / Platforms

Where it runs.

First-class on Claude Code, OpenAI Codex, Factory Droid, Cursor, xAI Grok Build, OpenCode, Muse Code, and Google Antigravity CLI. Same .flow/ directory, same commands, zero vendor lock-in. Specs reach a merged pull request on GitHub or Bitbucket Cloud, or a merged merge request on GitLab, gitlab.com or self-managed.

  • First-class

    Claude Code

    Anthropic's official CLI

    /plugin marketplace add \
      https://github.com/gmickel/flow-next
    /plugin install flow-next
    /flow-next:setup
    • Named subagents on model tiers your routing block can override
    • Both autonomous loops, flow --auto and land
    • Parallel task execution from one spec

    Uninstall

    rm -rf .flow/
  • First-class

    OpenAI Codex

    OpenAI's terminal-native agent

    git clone https://github.com/gmickel/flow-next
    cd flow-next
    ./scripts/install-codex.sh flow-next
    # then run /flow-next:setup in the repo
    • Multi-agent roles installed for you
    • Native GPT-family cross-model reviews
    • Works on Linux, macOS, and Windows

    Uninstall

    rm -rf .flow/ ~/.codex/plugins/flow-next
  • First-class

    Factory Droid

    Factory.ai's coding agent

    droid plugin marketplace add \
      https://github.com/gmickel/flow-next
    droid plugin install flow-next
    /flow-next:setup
    • Full command and subagent parity
    • Same .flow/ files, portable between harnesses
    • No translation step to maintain

    Uninstall

    rm -rf .flow/
  • First-class

    Cursor

    Anysphere's AI code editor

    # Recommended: team-marketplace import.
    # An admin imports gmickel/flow-next via the
    # Cursor GitHub App; it refreshes on push.
    
    # Individual fallback:
    ./scripts/install-cursor.sh   # Windows: .ps1
    # restart Cursor, then /flow-next:setup
    • One admin import puts it on every developer machine
    • Multi-agent planning verified, not assumed
    • One subscription reaches reviewer models from several families

    Uninstall

    rm -rf .flow/ ~/.cursor/plugins/local/flow-next
  • First-class

    xAI Grok Build

    xAI's terminal coding agent

    # Installed in Claude Code? Grok auto-reads it:
    grok inspect   # shows the flow-next skills
    # NOT 'grok plugin install <repo>' (it's a marketplace)
    • Zero-config on top of an existing Claude Code install
    • Multi-agent planning verified, not assumed
    • Same specs, tasks, and receipts on disk

    Uninstall

    rm -rf .flow/
  • First-class

    OpenCode

    Open-source terminal agent

    git clone https://github.com/gmickel/flow-next
    cd flow-next
    ./scripts/install-opencode.sh
    # restart OpenCode, then /flow-next-setup
    • One installer places skills, agents, and commands
    • Multi-agent planning and cross-model review verified
    • Uninstall is tracked, so nothing is left behind

    Uninstall

    ./scripts/install-opencode.sh --uninstall # per-repo state: delete .flow/
  • First-class

    Muse Code

    Meta's coding agent CLI

    git clone https://github.com/gmickel/flow-next
    cd flow-next
    ./scripts/install-muse.sh
    # muse --disable-sandbox, then /flow-next:setup
    • One installer builds, installs, and approves the Muse bundle
    • Scouts, workers, review, flow --auto, and land verified live
    • Cross-model review through a CLI backend

    Uninstall

    muse plugins remove flow-next # per-repo state: delete .flow/
  • First-class

    Google Antigravity CLI

    Google's coding agent CLI

    git clone https://github.com/gmickel/flow-next
    cd flow-next
    ./scripts/install-antigravity.sh
    # agy --settings '{"toolPermission":"always-proceed"}'
    # then /flow-next:setup
    • One installer maps agents to Antigravity tiers and checks every one loads
    • Plan with its scouts and work with per-task workers verified live
    • Drive it from your other hosts as an implementer or a reviewer

    Uninstall

    agy plugin uninstall flow-next # per-repo state: delete .flow/

13 / Subagents

Context before code.

Planning starts from evidence instead of guesswork: specialized agents read the repository, the docs, prior decisions, and past mistakes in parallel before a task is written. Each asks for a tier of model, never a vendor -- your routing block decides what answers -- and the read-only ones are denied the tools to write anything.

repo-scoutReasoning tier

Scans repo for prior patterns, conventions, related modules.

practice-scoutReasoning tier

Surfaces modern best practices and common pitfalls.

docs-scoutReasoning tier

Finds the exact framework/library docs relevant to the ask.

docs-gap-scoutReasoning tier

Flags which docs, comments, or READMEs will need updates after the change.

github-scoutReasoning tier

Searches public + private GitHub for implementations and examples.

spec-scoutReasoning tier

Cross-references other specs for dependencies and shared scope.

memory-scoutReasoning tier

Retrieves what past work in this module already learned the hard way.

why-scoutReasoning tier

Answers a why question from git history, the pull requests behind the commits, and the decision memory, and tiers each finding by how directly the record supports it.

flow-gap-analystReasoning tier

Maps user flows, edge cases, and missing requirements.

quality-auditorReasoning tier

Reviews changes for correctness, simplicity, security, coverage.

workerSession model

Implements one task of a multi-task spec in a fresh context window, re-anchored on the spec.

14 / Readiness

Is your repo ready for this?

Before any of this pays off, a codebase has to be legible to an agent. The readiness pass classifies the project, runs the commands it finds, and leads with the single highest-leverage next action -- because existence checks lie.

  1. 01

    Classify

    What kind of project is this

    Lifecycle, topology, size, stack, and delivery shape are pinned first, so the assessment judges a thirty-year-old monolith and a two-week prototype by the standards that apply to each.

  2. 02

    Verify

    Substance over existence

    Existence checks lie: a repository can carry agent instructions, a hook file, and a lint script and still be un-agentic in practice. The pass runs the build and test commands it finds and checks that the commands your instructions quote actually resolve.

  3. 03

    Gate

    What is actually broken

    The hard gates catch the lies -- the build runs, tests are discoverable when a framework is claimed, documented commands execute. Unverified counts as failed, never as probably fine.

  4. 04

    Rank

    Verdict and next actions

    The report opens with a verdict and the five highest-leverage things to fix, then offers to make the safe ones for you. No vanity maturity badge.

Nine scouts run in parallel and the whole pass takes under half a minute: tooling, build, tests, agent instructions, documentation, environment setup, CI and automation, security settings, and observability. Point it at another repository by path to triage a whole portfolio without checking anything out.

15 / Storage

The .flow/ directory.

Everything lives in .flow/. JSON metadata, Markdown content, one file per task. Merge-friendly, grep-friendly, diff-friendly.

.flow/
├── meta.json          # project config
├── config.json        # review backend, prefs
├── specs/             # spec markdown + JSON sidecar
│   ├── fn-1-add-oauth.md
│   └── fn-1-add-oauth.json
├── tasks/
│   └── fn-1.1-token-store.json
└── memory/             # opt-in, categorized
    ├── bug/             # build-errors, test-failures,
    │                    # runtime-errors, performance,
    │                    # security, integration, data, ui
    └── knowledge/       # architecture-patterns, conventions,
                         # tooling-decisions, workflow,
                         # best-practices, decisions

One file per task means merge conflicts are local, not global. No hosted database, no coordination server, nothing to buy. Grep it, diff it, commit it, delete it.

16 / Spec

Install + run.

Runtime
Python 3.11+, git
Platforms
Claude Code, Codex, Droid, Cursor, Grok, OpenCode, Muse Code, Antigravity CLI
Review backends
Codex CLI, Copilot CLI, Cursor, Claude CLI, a review command you set, host
Forges
GitHub, GitLab (gitlab.com or self-managed), Bitbucket Cloud
Trackers
Linear, GitHub, GitLab, Jira
Install format
Plugin marketplace
Uninstall
rm -rf .flow/
License
MIT

Quick start

/plugin marketplace add \
  https://github.com/gmickel/flow-next
/plugin install flow-next
/flow-next:setup

# say what you have; Flow picks the route
/flow-next:flow add oauth login

# or call a stage by name
/flow-next:capture add oauth login
/flow-next:work fn-1 --no-plan

# when you want a task breakdown first
# /flow-next:plan fn-1
# /flow-next:work fn-1

Free and MIT-licensed. Read the docs to go deeper, or bring someone in who has rolled this out before.

See also: Flow, the retired predecessor →

Tags
  • Claude Code
  • Codex
  • Factory Droid
  • Cursor
  • Grok Build
  • OpenCode
  • Muse Code
  • Antigravity CLI
  • Open Source