Plugin
One command. Sixty seconds.
npx @flowforge/core init installs 29 specialist AI agents, 35 quality rules enforced via git hooks, session persistence across conversations, and automatic time tracking.
$ npx @flowforge/core init
1 Developer + AI 4 Months +1.2M Lines of Code
Your AI writes the code.
FlowForge makes sure it's good code.
MIT researchers proved every AI coding agent degrades code over time. Zero exceptions. FlowForge is the tooling-level fix — 29 specialist agents, automated quality gates, and session persistence that turns chaotic AI development into production-grade software.
AI coding tools are fast. They're also reckless. Without guardrails, they produce god functions with cyclomatic complexity of 285, duplicate code at 2.2× human rates, and break their own prior work on 99.5% of iterative tasks. One developer using FlowForge built a medical AI platform with over 1.2 million lines of code across 14 domains in 4 months — work that would take a team of 6 over two years. The difference wasn't the AI. It was the system around it.
29 Specialist Agents
80%+ Test Coverage
+1.2M Lines of Code
97% Quality Seal
AI Code Degrades.
Every Time.
MIT Proved It.
SlopCodeBench (UW-Madison, WSU, MIT) tested 11 frontier AI models across 93 iterative checkpoints. The results should worry every engineering leader.
Structural Erosion
| Checkpoint # | Human code erosion | Agent code erosion |
|---|---|---|
| 1 | 0.31 | 0.40 |
| 2 | 0.31 | 0.46 |
| 3 | 0.31 | 0.51 |
| 4 | 0.31 | 0.57 |
| 5 | 0.31 | 0.63 |
| 6 (93) | 0.31 | 0.68 |
Agent code erodes. Human code doesn't.
Code Verbosity
2.2× more redundant code.
Prompt Engineering
| Prompt style | Start intercept | Slope |
|---|---|---|
| Default prompt | 0.40 | Same |
| Quality prompt (+47.9% cost) | 0.30 | Same |
Better prompts shift the start. Not the slope.
Zero full solutions. Not a single AI agent completed a full iterative coding task without degrading the codebase. The models tested included GPT-4o, Claude 3.7 Sonnet, Gemini 2.0 Flash, and 8 others. All failed.
80% of trajectories show structural erosion. As AI agents iterate — fixing bugs, adding features, responding to follow-up prompts — the maintainability index deteriorates consistently. More checkpoints means worse code, guaranteed.
89.8% of trajectories show growing verbosity. Agents duplicate logic, over-comment, pad functions, and accumulate dead code at 2.2× the rate of human developers. Your codebase silently inflates with every session.
Prompt engineering does not fix this. More detailed instructions improve starting quality, but the degradation rate remains identical. This is a structural property of AI-driven iteration — not a prompting problem.
More money does not help either. Mean cost per checkpoint grows 2.9× ($1.46 to $4.17) with zero quality improvement. Spending more on larger models or longer prompts accelerates cost while the erosion trajectory stays identical.
"Prompt pressure shifts the starting point but not the rate."
Three Layers. One System. Zero Slop.
FlowForge wraps AI development in quality guardrails at every level — from solo developer to enterprise team.
TUI Controller
Mission control for AI development.
A terminal UI that spawns multiple Claude Code workers in parallel, shows real-time context usage per terminal, manages a micro-task queue, and lets you merge PRs with a single keystroke.
$ flowforge tui
Team Dashboard
Intelligence for managers who don't write code.
A PRD creation wizard that turns plain-language feature descriptions into structured specs with tickets and estimates — giving your whole team a shared source of truth.
$ flowforge dashboard
Feature Details
Layer 1 — Free
Drop-in quality layer
for Claude Code
One command installs 29 specialist AI agents, 35 quality rules enforced via git hooks, session persistence across conversations, and automatic time tracking. No config files. No learning curve.
- 29 specialist agents — architecture, testing, security, frontend, backend, and more
- 35 rules enforced automatically — via pre-commit and pre-push hooks
- Session persistence — context survives across conversations
- Time tracking — every minute of work is logged to the issue
Layer 2 — $29/mo
Mission control for
multi-agent development
A terminal UI that spawns multiple Claude Code workers in parallel, shows real-time context usage, manages a micro-task queue, and lets you merge PRs with a single keystroke.
- Multi-terminal orchestration — run 4+ Claude workers side by side
- Live context budget — see token usage per terminal in real time
- Micro-task queue — break epics into parallelizable units automatically
- One-keystroke PR merge — review, approve, and merge without leaving the terminal
Layer 3 — $79/mo
Intelligence for
the whole team
A web dashboard that turns plain-language feature descriptions into structured PRDs with tickets and estimates — giving your entire team a shared source of truth.
- PRD wizard — describe a feature in English, get a structured spec
- Auto-estimation — tickets generated with time estimates from historical data
- Team velocity — track who shipped what, when, and how long it took
- Quality metrics — code review scores, test coverage, rule compliance per developer
One Developer. Four Months. A Medical AI Platform.
DELPHOS is a healthcare intelligence platform running 5 AI models on-premise, serving real clinical workflows. It was built by one developer with FlowForge and Claude Code.
Traditional Team
- 6 engineers — $840k/yr salary burn
- 24-month delivery timeline
- $40h/month in coordination meetings
- Inconsistent quality across engineers
- Context lost at every handoff
FlowForge + 1 Dev
97/100% Quality Seal
- 1 developer — fraction of the cost
- 4-month delivery from zero to production
- 11 parallel terminals, zero coordination overhead
- 35 automated quality rules enforced on every commit
- Full session persistence — zero context loss
lines of code
AI models
test coverage
quality seal
tool bridges
quality rules
domains
to build
Traditional software teams need a frontend specialist, backend engineer, database architect, DevOps engineer, QA engineer, and a tech lead just to ship a feature. Coordination alone consumes 30–40% of engineering capacity before a single line of production code is written.
FlowForge replaces the coordination layer with automated quality gates and specialist AI agents — each with a focused domain, enforced rules, and a handoff protocol that preserves context across every session. The result is verifiable: over 1.2 million lines of code, 5 running AI models, 80%+ test coverage, and a 97/100% documentation-implementation quality seal earned through a structured gap-analysis process.
How FlowForge Works: The Maestro Pattern
Your AI doesn't need more training. It needs a system.
$ npx flowforge session:start #142
[FF] Timer started: 00:00:00
[FF] Branch: feature/142-command-consolidation
[FF] Context loaded: 3 handoff items
[FF] Agent: fft-backend (auto-selected)
[FF] Task: Consolidate session commands (est. 20 min)
[FF] Ready. Tests first.
Always Consult, then Execute
Every significant decision in a FlowForge session follows the same pattern: the orchestrating agent presents three implementation options with trade-offs, waits for developer approval, and only then delegates to the appropriate specialist. No code is written without a human decision point — which means no surprise architectural debt, no undocumented shortcuts, and no "I'll fix it later."
29 Specialist Agents.
Each One an Expert.
Instead of one AI doing everything badly, FlowForge routes each task to a domain specialist.
Architecture & Planning
fft-architecture
System design, 3-option analysis
fft-project-manager
Sprint planning, micro-tasks
fft-api-designer
API contracts, OpenAPI specs
fft-product-owner
Requirements, acceptance criteria
Development
fft-backend
Node.js, Python, Go
fft-frontend
React, Vue, Angular
fft-database
PostgreSQL, schema design
fft-ios
Swift, SwiftUI, UIKit native iOS development
fft-android
Kotlin, Jetpack Compose native Android development
fft-flutter
Dart, Riverpod cross-platform development
Quality & Security
fft-testing
TDD, coverage, E2E
fft-code-reviewer
Erosion, verbosity, security
fft-security
OWASP, threat modeling
fft-performance
Load testing, optimization
fft-qa
Full-stack quality assurance
Operations & Documentation
fft-devops-agent
Docker, CI/CD, IaC
fft-documentation
API docs, ADRs
fft-github
Branch management, PRs
fft-designer
UI/UX, design tokens
fft-brand-architect
Brand identity, color theory, design tokens
fft-documenter-br
Brazilian Portuguese documentation
Marketing & Content
fft-content-strategist
Landing page copy, SEO, conversion
fft-social-media
Multi-platform social content and analytics
AI / ML Specialists
fft-ml-architect
Strategy, model selection
fft-llm-openweight
Local models, quantization
fft-rag-engineer
Retrieval, embeddings
fft-agent-frameworks
CrewAI, LangChain
Specialized
fft-medical
Healthcare, HIPAA
fft-agent-creator
Creates new specialist agents
See What Your Team Is
Actually Doing.
FlowForge's Team Dashboard turns developer activity into business intelligence.
Ideas to Milestones in 5 Minutes
Describe a feature in plain English. FlowForge generates a full PRD, user stories, and micro-tasks — ready to sprint.
I need doctors to see their daily schedule, drag appointments to reschedule, and get notified when a patient cancels.
PRD generated Done
8 user stories 8
24 micro-tasks 24
~12 hours estimated ~12h
Estimation That Works
Replace abstract story points with deterministic 10–30 minute tasks. Velocity becomes a real number, not a negotiation.
Old Way
- Story points
- Arguments in planning
- Unpredictable velocity
New Way
- 10–30 min tasks
- Deterministic scope
- Predictable delivery
Dev A 12 tasks/day
Dev B 8 tasks/day
Team 47 tasks/day
Every Minute Accounted For
Git hooks capture start and end of every task. Billable hours are calculated automatically — no manual timesheets.
Less More
Billable hours calculated automatically
Weekly Reports, Zero Effort
Every Monday, stakeholders receive an auto-generated PDF with velocity trends, burndown, and time-per-feature breakdown.
47 Tasks done
38.5h Billable
94% On track
The Science Behind
FlowForge
SlopCodeBench is the first large-scale benchmark of how AI coding agents degrade code over iterative development.
| SlopCodeBench Finding | Impact | FlowForge Solution |
|---|---|---|
| 0% end-to-end solve rate | No AI can maintain a codebase alone | 29 specialist agents |
| 80% structural erosion | God functions, cyclomatic complexity = 285 | CC gates at CC > 10 via hooks |
| 89.8% growing verbosity | 2.2× human code volume | AST duplication detection |
| Prompt engineering same slope +47.9% cost | Better prompts don't prevent degradation | Tooling level, not prompt level |
| Regression failures 0.5%/iter | New features break existing behaviour | TDD enforcement, 80%+ coverage |
| Cost grows 2.9× | More spending, no quality improvement | Architecture-first, micro-tasks |
- Finding
- 0% end-to-end solve rate
- Impact
- No AI can maintain a codebase alone
- FlowForge Solution
- 29 specialist agents
- Finding
- 80% structural erosion
- Impact
- God functions, cyclomatic complexity = 285
- FlowForge Solution
- CC gates at CC > 10 via hooks
- Finding
- 89.8% growing verbosity
- Impact
- 2.2× human code volume
- FlowForge Solution
- AST duplication detection
- Finding
- Prompt engineering same slope +47.9% cost
- Impact
- Better prompts don't prevent degradation
- FlowForge Solution
- Tooling level, not prompt level
- Finding
- Regression failures 0.5%/iter
- Impact
- New features break existing behaviour
- FlowForge Solution
- TDD enforcement, 80%+ coverage
- Finding
- Cost grows 2.9×
- Impact
- More spending, no quality improvement
- FlowForge Solution
- Architecture-first, micro-tasks
| Checkpoint | Without FlowForge (quality score) | With FlowForge (quality score) |
|---|---|---|
| 1 | 0.40 | 0.38 |
| 2 | 0.48 | 0.35 |
| 3 | 0.55 | 0.37 |
| 4 | 0.62 | 0.34 |
| 5 | 0.67 | 0.36 |
| 6 | 0.72 | 0.33 |
| 7 | 0.76 | 0.35 |
| 8 | 0.79 | 0.32 |
| 9 | 0.81 | 0.34 |
| 10 | 0.82 | 0.30 |
Reference: Orlanski, G., Roy, D., et al. (2026). SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long-Horizon Iterative Tasks. arXiv:2603.24755.
Live on FlowForge Pro
You describe the goal.
You describe the goal.
FlowForge builds it.
ForgePlay orchestrates your entire specialist agent team automatically — from blank canvas to production-ready output, in a single command.
Most development bottlenecks aren't technical. They're coordination. Thirteen back-and-forth threads to align a designer, a backend engineer, a security reviewer, and a tester on a single feature.
ForgePlay eliminates the coordination layer entirely. Pick a play. Describe your goal. Watch 6 specialist agents work in parallel while you focus on what actually matters.
From product name to live page.
No brief. No back-and-forth. No delays.
Tell ForgePlay your product name and vision in plain language. It handles everything else.
Agent pipeline: Brand Architect and Content Strategist run in parallel with Designer, then outputs converge into Frontend Engineer, then Quality and Performance, then Code Reviewer.
- Brand Architect Creates your logo, selects a color palette, and generates design tokens that define your brand.
- Content Strategist Writes headlines, feature copy, and SEO-ready page text aligned to your audience and conversion goal.
- Designer Designs screen layouts and component specifications — pixel-perfect, accessibility-compliant.
- Frontend Engineer Builds the actual page. Responsive. Production-grade.
- Quality & Performance Validates accessibility, Core Web Vitals, and cross-browser rendering.
- Code Reviewer Final quality gate before merge. Zero shortcuts.
Result: A production-ready landing page. One play. 6 specialists. Zero context switching.
What used to take 3 weeks of stakeholder alignment now ships in a single session.
Point. Click. Billing live.
Point ForgePlay at your existing codebase. It designs the payment flow, implements the backend logic, builds the checkout UI, locks down PCI compliance, and writes the tests — all in one coordinated run. No payment consultants. No security reviews that take two weeks. No "we'll add tests later."
- Architect Designs your payment flow with 3 implementation options — you choose, it builds.
- API Designer Defines Stripe webhook endpoints and subscription management contracts.
- Backend Engineer Implements payment logic, retry handling, and failed-charge recovery.
- Frontend Engineer Builds the checkout UI and subscription management screens your users actually see.
- Security Specialist PCI compliance audit. Every endpoint reviewed. Every data surface validated.
- Testing Engineer End-to-end payment flow tests. Happy path. Failure scenarios. Webhook edge cases.
Result: Working Stripe integration — subscriptions, webhooks, failed-charge recovery. Tested. Secure. Merged.
The tech gap goes to zero.
Right now, a non-technical idea has to travel through a chain of translators before it becomes a ticket a developer can act on.
The marketing lead describes the feature. The PM writes a brief. The tech lead translates it into requirements. The architect turns those into tasks. The project manager estimates effort. By the time the developer opens the ticket, the original intent is three conversations removed.
ForgePlay cuts the chain to one step.
Describe your idea in plain language.
Receive a complete sprint, ready for your dev team.
A CEO, a department head, an operations manager — anyone on your team can open the ForgePlay chat, describe what they need in natural language, and walk away with a fully structured sprint: PRD, architecture decision, timeline, milestones, every ticket written.
No technical translator required. No three-meeting process. No "let me loop in the CTO first."
- Architect Analyzes the idea for technical feasibility, creates a PRD and architecture decision record, presents 3 implementation approaches.
- Project Manager Breaks the chosen approach into milestones, estimates timelines, identifies dependencies.
- Product Owner Writes every ticket. Estimates effort in hours. Calculates cost. Prioritizes the backlog.
Result: A complete sprint your dev team can execute on day one. Time estimate. Cost projection. Every ticket written. Nothing lost in translation.
The HR manager who needs a compliance feature can now prepare the full sprint herself and send it directly to the CTO for approval. No meetings. No miscommunication. No wasted cycles.
No credit card required · Setup in 4 minutes · Cancel anytime
Team & Pro Plans
See everything.
See everything.
Every metric. Every developer. Every sprint.
The FlowForge Dashboard gives engineering leaders complete visibility — not summaries, not estimates, not status-update theatre. The actual numbers. In real time.
Team Velocity
| Mon | Tue | Wed | Thu | Fri |
|---|---|---|---|---|
| 65% | 80% | 55% | 90% | 72% |
Team
- Alex Backend
- Maria Frontend
- Jo Testing
- Lucas DevOps
Sprint v3.1 68%
- Core CLI
- TUI Panel
- Dashboard
- Docs
ForgePlay
Ship Landing 3 / 6 agents
- brand done
- content active
- designer active
- frontend queued
- testing queued
- reviewer queued
Tower control for your engineering team.
Every metric your team generates — tasks completed per day, PR cycle time, code quality scores, sprint velocity — visible in one place, updated in real time.
No end-of-week report that's already three days old. No stand-up where you discover a blocked ticket that's been sitting since Tuesday.
Tasks / Day
Individual daily output, trended over the last 30 days.
PR Cycle Time
Average hours from open to merged. Per developer and team-wide.
Code Quality Score
Composite from code review findings, test coverage, and complexity metrics. Tracked over sprints.
Time Tracking & Billing
Automatic session logging tied to tickets. One-click PDF billing reports for clients.
Your Monday morning 30-minute sync becomes a 5-minute glance.
Level up your entire team.
Automatically.
FlowForge monitors how each developer works — what they build, where code review finds issues, where tickets stall, where coverage drops. Then it tells you exactly what each person needs to improve.
Not a generic training catalog. An individual development plan, generated from actual work patterns.
Strong on backend architecture. Frontend testing coverage consistently below team average. Recommended: 3 targeted exercises, 2 documentation references, 1 practice ticket pre-loaded in the backlog.
Fast delivery velocity — top quartile on tasks per day. Code review findings run 3× higher than team average, concentrated in error handling and edge cases. Recommended: Error-handling deep-dive module, curated examples from merged PRs, weekly review pairing.
Every knowledge gap identified. Every training plan written. Your team gets stronger every sprint — without a learning management system, a training budget, or a dedicated session.
The tech gap goes to zero.
Non-technical leaders have always been one report away from understanding what the team is actually building. That report arrives on Friday. The problem it describes happened on Wednesday.
The FlowForge CTO View updates continuously. Sprint progress, budget burn rate against delivery, risk flags, active ForgePlay workflows — everything visible, everything actionable.
Sprint Progress
Ticket completion percentage, open vs closed, days remaining. One glance to know if the sprint is on track.
Budget Burn vs Delivery
Actual hours logged against projected estimate. Cost variance flagged before it becomes a problem.
Risk Flags
Blocked tickets older than 24 hours. PRs open longer than team average. Test coverage trending down. Flags surface automatically — no one has to notice.
ForgePlay Status
Active plays, completed plays, plays awaiting approval. Approve a plan without opening a Slack thread.
You stop asking "where are we?" because the answer is always one tab away.
The right information reaches the right person automatically.
Weekly summaries to Slack. Monthly PDF reports for stakeholders. Velocity and burndown charts generated without a data analyst. Individual contribution exports for performance reviews.
And when your team already lives inside Notion, Linear, or Jira — FlowForge pushes to all of them.
- Automatic stakeholder reports (weekly / monthly)
- Velocity, burndown, and contribution charts
- Slack and email digest summaries
- Export to Notion, Linear, Jira
- Client billing reports — one click, always accurate
See the dashboard in action
Start free — no credit card
Works with your existing tools. No migration required.
Start Free. Scale When You're Ready.
Every plan includes the Plugin. Upgrade for mission control and team intelligence.
$0
- 8 specialist AI agents
- 15 quality rules with git hooks
- Session management
- Context persistence via handoffs
- Time tracking (local)
- GitHub integration
Most Popular
$29 /month per dev
- Everything in Free, plus:
- All 29 specialist agents
- TUI Controller
- 7+ parallel workers
- Context % monitoring
- Micro-task queue
- One-key PR merge
- Priority support
$79 /month per dev · min 3
- Everything in Pro, plus:
- Team Dashboard (web)
- PRD Creation Wizard
- Sprint board with velocity
- Time analytics
- Automated weekly PDF reports
- Multi-provider
Custom
- Everything in Team, plus:
- SSO/SAML
- Audit logging
- Self-hosted option
- Custom agent development
- Dedicated onboarding
- SLA
Built and Battle-Tested on Real Software
FlowForge doesn't just claim quality. Every metric below comes from a production multi-domain system built exclusively with FlowForge-managed AI sessions.
0 Lines of code
0 AI models integrated
0 Test coverage floor
0 Quality seal score
0 Bridges built
0 Quality rules
0 Medical domains
0 Months in production
-
I stopped worrying about whether the AI would produce garbage. The hooks catch it.
Production developer -
Context persistence changed everything. I used to spend 30 minutes every morning re-explaining.
Solo developer -
The micro-task system killed our estimation meetings.
Team lead, 4-dev team
Before vs After FlowForge
| Metric | Before | After FlowForge |
|---|---|---|
| Context re-explanation | 20–30 min per session | 0 min |
| Tests per feature | Optional | Mandatory 80%+ |
| Commits to main | Frequent | Never (branch + PR) |
| Estimation accuracy | ±40% | ±15% |
| Code review | Sometimes | Always (auto + human) |
| Time tracking | Self-reported | Automatic |
60 Seconds to Your First Guarded Session
No configuration wizard. No onboarding tutorial. One command, and your AI has guardrails.
-
$ npx @flowforge/core init Installing FlowForge... ✓ Created .flowforge/ ✓ Installed 8 specialist agents ✓ Registered 15 git hooks ✓ Ready in 4.2s
-
$ flowforge session:start feature/142-command-consolidation Session sess_1745000000000_a1b2c3d4 started on branch "feature/142-command-consolidation".
-
[PASS] Branch protection — feature/142-command-consolidation [PASS] Test coverage — 84.2% (threshold: 80%) [PASS] File size — 342 lines (limit: 700) [PASS] Complexity — CC=6 (threshold: 10) [PASS] JSDoc coverage — 100% exports documented [FAIL] Console statements — Found console.log at line 47
-
$ flowforge session:end Session completed (2h 15m). 8 commit(s), 12 file(s) changed.
15 rules enforced via git hooks
[PASS] Branch protection No direct main commits [PASS] Test coverage 80%+ threshold enforced [PASS] File size limit 700 lines max per file [PASS] No console.log Production code clean [PASS] Commit format Ticket reference required [PASS] JSDoc coverage Exports documented [PASS] Complexity threshold CC < 10 enforced [PASS] No TODO comments Production code clean [PASS] No debug statements breakpoint/debugger blocked [PASS] Mandatory TDD Test before implementation [PASS] PR review required Auto + human approval [PASS] Conventional commits Semantic messages [PASS] Changelog updated On feature merges [PASS] Dependencies pinned Exact versions [PASS] Security scan npm audit + dependabot
8 Specialist Agents Included Free
-
fft-architecture -
fft-backend -
fft-frontend -
fft-testing -
fft-code-reviewer -
fft-database -
fft-documentation -
fft-project-manager
TUI Controller — Pro Plan
+--[ FlowForge Controller ]------+ | [*] W1 #142 02:12 [CTX: 34%] | | [ ] W2 #143 00:22 [CTX: 67%]! | | [ ] W3 #89 01:45 [CTX: 12%] | | Merge: PR #892 [Ready] | +--------------------------------+
Run 7+ parallel Claude Code workers. Monitor context usage. Merge PRs without leaving the terminal.
Your AI Is Fast. Make It Professional.
MIT proved the problem. DELPHOS proved the solution. Your turn.
FlowForge is free to start and takes 60 seconds to install. Eight specialist agents. Fifteen quality gates. Session persistence. Time tracking. All enforced automatically.
npx @flowforge/core init