FlowForge · BA/PO Pipeline Proposal

Closing the upstream gap

FlowForge accelerates engineering with 15 agents across 5 steps. The BA phase has 3 agents in .require — all operating after the spec is written. The 6–10 hours before the spec exists have no tooling. And non-technical BAs face a hidden git barrier before they can even start.

3
agents on .require today
15
agents on dev pipeline
27
total BA-side agents proposed

The problem

The asymmetry today

Steps 02–06 are built for developers — 15 agents, automated, structured. Step 01 has 3 agents — all post-spec-capture. The 6–10 hours before the spec gets written have nothing.

What .require actually does today: After the human writes the spec using guided prompts, three agents fire in sequence. Gap Reviewer (Explore sub-agent, Phase 1) finds holes the author missed. Self-Review (Phase 2) has the main agent switch to critical reviewer mode and challenge its own spec. QA Author (Phase 3) generates the test skeleton. All three are post-capture — none of them help you discover what to build.
Git barrier — critical adoption blocker for non-technical BAs/POs: FlowForge requires two manual git operations that most BAs have never done. (1) Pull before every step: git pull origin master must be run manually before starting any new feature. Forgetting it is silent — no error, just stale context. (2) Branch dependency trap: /flowforge.require creates a feature branch immediately from whatever the current HEAD is. If feature A's branch hasn't been merged yet, feature B's branch is parented on A — creating an implicit dependency that isn't visible until .plan or .build fails on unrelated changes. A non-git user has no way to know this is happening. Neither issue is in scope for the current BA pipeline proposal, but both must be resolved before non-technical BAs can run FlowForge independently.
3
agents on .require — all post-capture
BA / PO
  • Problem framing none
  • Existing landscape research none
  • Solution option exploration none
  • Spec writing — guided prompts, human-driven human + prompts
  • Gap Reviewer — Explore sub-agent finds spec holes (Phase 1, Step 5) 1 agent
  • Self-Review — main agent switches to critical reviewer mode (Phase 2) 1 agent
  • QA Author — generates QA skeleton after approval (Phase 3) 1 agent
  • Epic decomposition none
  • Refinement facilitation none
The upstream gap: All 3 existing agents run only after the spec exists. They improve spec quality — but they can't surface a wrong problem, missing context from Confluence/Jira, or a better solution approach. That work still happens manually, before anyone opens .require.
15
agents across 4 steps
Dev
  • .plan — 6 parallel reviewers + Devil's Advocate 6 agents
  • .analyze — 3 parallel gap finders 3 agents
  • .build — TDD pipeline (Builder + Test Validator) 2 agents
  • .verify — 4 compliance checks + Devil's Advocate 4 agents
  • .fix — circuit-breaker repair (max 3 rounds) built-in
  • Express/Fast — full Jira→PR auto-gen auto
  • Traceability chain spec → QA end-to-end

Time audit

Where the time actually goes

A standard feature before it reaches .plan. The 3 post-capture agents save ~20–30 min on spec quality; everything before the spec is written has no tool support at all.

Problem framingstakeholder alignment
no tool support
2–4h
Landscape researchJira, Confluence, codebase
no tool support
1–3h
Spec + AC writing/flowforge.require (guided prompts)
human-driven guided prompts
2–4h
Gap review + self-review + QA draft3 post-capture agents
automated (~20–30min)
~0.4h
Refinement prepagenda, options, open Qs
no tool support
1–2h
Refinement session+ spec edits
no tool support
1–3h
.plan → .build → .verifyFlowForge dev pipeline
fully automated
0.5–1h
No tool support
Partial support
Fully automated by FlowForge

The proposal

The full pipeline — proposed

Seven new commands + one enhanced command extend the BA pipeline. A new pre-flight step eliminates the git barrier for non-technical users. Today's 3 agents all review the spec after you write it — the proposal adds agents for everything before and around that moment.

Pre-flight — git barrier elimination
00
/ff.start
new · blocker fix
Eliminates the two git blockers for non-technical users. Pulls latest master automatically — no manual git pull required. Checks for unmerged branches: if a prior feature branch exists and hasn't been merged, warns the user before creating a new one — preventing silent branch dependency traps. Creates the feature branch from a clean, up-to-date HEAD.
Git Pre-flightBranch Conflict Detector
BA / POclean branchautomated
BA / PO zone — upstream
01
/ff.discover
new
Agent-driven interview frames the business problem before any spec writing starts. Forces articulation of success metrics, user impact, and regulatory constraints.
Problem FramerJourney MapperValue ValidatorRisk Spotter
BA / PO0-discovery.md4 agents
02
/ff.research
new
Scans Confluence, Jira, and the codebase — surfaces related epics, prior decisions, established patterns. The spec is grounded in what the system already does.
Confluence ScannerJira LinkerPattern Scout
BA / PO0-research.md3 agents
03
/ff.ideate
new
Generates 3–4 structured solution options — fast-to-ship vs. clean architecture vs. lowest risk. A Recommender agent proposes a preferred option. BA picks one; that anchors the spec.
Option Generator ×3RecommenderLane Estimator
BA / PO0-options.md5 agents
04
/ff.require
enhanced
Spec capture (guided prompts, unchanged) + an expanded review panel. The 3 existing agents stay — Gap Reviewer, Self-Review, and QA Author. 5 new specialist agents join them. Catches ambiguity, missing edge cases, and GDPR implications before the dev pipeline sees it.
Gap Reviewer ✓ Self-Review ✓ QA Author ✓ Completeness Auditor Edge Case Hunter Ambiguity Detector GDPR Probe Scope Guard
BA / PO1-spec.md8 agents (3 existing + 5 new)
05
/ff.split
new
Decomposes epics into independently deliverable stories, identifies the minimum viable slice, marks hard dependencies, suggests lane per story.
Story SlicerDependency MapperMVP Identifier
BA / PO0-split-map.md3 agents
06
/ff.refine
new
Pre-session: structured agenda, open Qs, lane signal, cross-team deps. Post-session: paste in decisions; agent updates spec and Jira automatically.
Agenda BuilderDecision TranscriberJira Sync
BA / POmeeting prep3 agents
07
/ff.prd
new
Assembles discovery, options, spec, lane into a stakeholder-ready PRD — publishes to Confluence automatically. Zero-cost byproduct of the flow.
Document AssemblerConfluence Publisher
BA / POConfluence page2 agents
Handoff to dev pipeline — only after spec has passed the full BA review panel. Lane suggestion pre-calculated from ideate + split output.
Dev zone — existing pipeline, unchanged
08
/ff.lane
existing
Auto-detect or assign process lane. Now informed by ideate + split output — lane arrives pre-calculated.
Dev
09
/ff.plan
existing
Technical plan + 6-agent review. Higher-quality spec = fewer plan iterations.
Dev6 agents
10
/ff.analyze
existing
Gap analysis. CRITICAL gaps that previously surfaced here are now caught upstream by the BA review panel.
Dev3 agents
11–13
/ff.build · verify · fix
existing
TDD code generation, spec compliance verification, auto-fix. Unchanged — but operating on a verified, complete spec.
Dev6 agents

Estimated impact

What changes

Grounded in the current team size — 19 FlowForge users, 55 active tickets — observed cycle time, and where time is spent today. Baselines credit the 3 existing agents in .require.

BA / PO time per feature
−45%
Hours saved upstream
Research agent replaces 1–3h of manual Jira/Confluence archaeology. Expanded review panel and ideation reduce rework in refinement. The 3 existing agents already save ~20–30min on spec quality — the proposal targets the other 6–9h. 3–7h net saved per standard feature.
Spec bounce rate at .analyze
−50%
Fewer critical gaps hitting dev pipeline
The existing 3 agents (Gap Reviewer, Self-Review, QA Author) already catch some spec issues post-capture. The 5 new BA review agents (Completeness, Edge Case, Ambiguity, GDPR, Scope) catch the rest — before the dev has invested time in .plan. Revised down from −65% to credit existing partial coverage.
Refinement meeting duration
−35%
From exploration to decision
/ff.ideate generates 3–4 structured options before the meeting. The session becomes a decision, not an exploration. 90+ min → ~60 min. Revised from −40% — ideation only eliminates option-generation time, not all discussion overhead.
FlowForge adoption reach
2–3×
More people who can drive it
FlowForge currently has a BA entry point that relies on the 3 post-capture agents in .require. With a full upstream pipeline (discover → research → ideate → require → split → refine → prd), BAs and POs initiate and run the entire upstream flow independently. Estimate unchanged — structural shift, not incremental.
Total cycle time (problem → PR)
−33%
Compresses the dominant term
Current: 7–13h BA upstream + 0.5–1h FlowForge dev pipeline. The 3 existing agents save ~20–30min on spec quality. The proposed pipeline targets the remaining 6–9h. Revised down from −40% to account for partial existing coverage and adoption friction in early phases.
Spec quality floor
↑↑
Higher baseline for .plan input
Today: Gap Reviewer + Self-Review catch spec holes; QA Author drafts test skeleton. Proposed: every spec has also been through discovery, research grounding, and 5 additional specialist agents. The .plan reviewers already apply this pattern technically — the proposal replicates it upstream at the requirements layer.

Cycle time

Before vs after

Standard feature, business problem to merged PR. Each segment is a phase. Hover for details.

Today 4–6 days total
~7–14h
2–4h
1–3h
2–4h
2–4h
rework
With BA Pipeline 2.5–4 days total
~4–8h
1–2h
No tooling — manual work
Partial / rework
Agent-assisted BA work
FlowForge dev pipeline (automated)
−33%
Revised estimate: 4–6 days → 2.5–4 days total cycle time from business problem to merged PR. The 3 existing .require agents save ~20–30min; the proposed pipeline targets the remaining 6–9h of manual upstream work. Revised down from −40% to account for partial existing coverage and expected adoption friction in early phases (discover, ideate). Express and Fast lanes still benefit most: the Jira→PR automation bottleneck is spec quality, not pipeline speed.

Why it compounds

Each phase determines the floor for everything below

The weak link is at the top. The current pipeline is only as good as the spec that enters it.

The quality cascade
BA
Discovery output → spec quality
A spec written without problem framing produces ACs that are technically complete but solve the wrong thing. The 3 existing .require agents catch spec holes — but none of them can flag a misaligned problem statement. Only production or sprint review does.
BA
Spec quality → plan iterations
Every ambiguity surfaces as a question during .plan. The 6 plan-review agents flag it, work bounces back to the BA. One cycle = half a dev day wasted before any code is written.
Dev
Plan quality → build correctness
Vague plan → vague tasks → implementation that passes .verify technically correct but doesn't meet business intent. The failure that's hardest to catch.
Dev
The expanded BA panel replicates a pattern already proven in .require
The existing Gap Reviewer + Self-Review already prove that spec-review agents catch gaps human review misses. Adding 5 specialist reviewers scales that further — the same bet .plan makes with 6 technical reviewers, applied one step upstream.
Where this won't land as predicted
hard blocker
Git pull — silent stale context
Every FlowForge step requires git pull origin master first. A non-technical BA will not know to do this. The failure is silent — FlowForge runs against stale code, produces a spec grounded in the wrong baseline. No error is raised. Addressed by /ff.start, but until that ships, this is a guaranteed failure mode for any BA using FlowForge without a dev standing by.
hard blocker
Branch dependency trap — invisible chaining
/flowforge.require creates the feature branch immediately from the current HEAD. If a prior feature branch is still open (not merged), the new branch is parented on it — creating an implicit dependency. When the first feature changes or is rebased, the second breaks silently. A BA starting two features in sequence will hit this every time and have no idea why. Addressed by /ff.start's branch conflict check, but the current tool has no guard at all.
soft risk
Discovery resistance
/ff.discover depends on BAs trusting an agent-driven interview. First runs will need heavy human correction. Adoption lags the more mechanical commands.
soft risk
Refinement facilitation
Post-session spec sync only works if the meeting produces structured decisions. Many refinements end with "we'll discuss further" — the tool can't force resolution.
soft risk
Org dependency
Cycle-time impact depends on BAs adopting FlowForge as their primary workflow. If BAs use it as a final formatting step, the upstream gains don't materialize.
soft risk
Adoption curve
Commands that ship first (research, require enhancement, prd) validate the model before exploratory ones (discover, ideate) need to be trusted.

Build sequence

Not all 7 commands at once

Start where friction is highest and trust is easiest to build. Each phase validates the model for the next.

Phase 1 — Quick wins
Mechanical · high-trust
/flowforge.start ← git blocker fix
/flowforge.research
/flowforge.require (+ 5 new agents)
/flowforge.prd
/ff.start is the prerequisite for all other BA commands — pull + branch safety check, zero learning curve. Research replaces hours of manual lookup. The 5 new review agents extend an existing command. PRD is a zero-cost Confluence byproduct.
Phase 2 — Refinement layer
Higher leverage · needs trust
/flowforge.split
/flowforge.refine
/flowforge.ideate
Epic decomposition is already done manually — tool just structures it. Refinement meeting prep is easy to validate. Ideation is most useful when framing is already known.
Phase 3 — Full upstream
Transformative · BA-led
/flowforge.discover
Full BA-owned flow
At this point BAs run the entire upstream pipeline independently, handing a verified, research-grounded, agent-reviewed spec to the dev pipeline. FlowForge becomes a full product development tool.