Software Factory,
reviewed in depth.
Four Forward Deployed Engineers at Avanai took 8090.ai's Software Factory and built four real applications with it, end to end. This is what we found: the strengths, the rough edges, and where we think it should go next.
Reviewers: Midhun Jose · Rohan Dhanawade · Shruti Saxena · Aemal Sayer
At its core is a knowledge graph linking requirements to architecture to implementation - so when one thing changes, everything stays in sync.
What is Software Factory?
Software Factory (by 8090.ai) is an AI-native SDLC orchestration platform - a single source of truth for PMs, designers, engineers, and QA to build from. It doesn't write your production code; it orchestrates everything around the code through five modules sitting on a shared knowledge graph. Coding agents like Claude Code connect over MCP, pull work orders as their contract, and build against the spec.
Grounded by uploaded artifacts (briefs, schemas, screenshots) and the knowledge graph: requirement → blueprint → work order → commit. When one thing changes, everything stays in sync - that traceability is the product.
Four engineers. Four real apps. One honest verdict.
No toy demos: each reviewer pushed a real project through the full pipeline - connected a GitHub repo, generated requirements and blueprints, planned work orders, and drove Claude Code over MCP to running, committed software.
Midhun Jose
Wegweiser - a companion app helping immigrants in Germany navigate bureaucracy. 20 work orders, 6 phases, feedback loop closed in production style.
Rohan Dhanawade
Quotation Generator - a local-first desktop app producing branded PDF quotes. Full define → design → plan → build cycle for ~$4.
Shruti Saxena
Foremost - a priority-based task manager. 10 work orders, 10 commits, Playwright-verified builds, statuses round-tripping over MCP.
Aemal Sayer
AvaTask - the same Kanban task app built three times with three different setups, compared side by side on video.
Use the arrow keys or the buttons below to move through the deck. On the screenshot gallery, the arrows browse images first.
Wegweiser: from design notes to a working product
Midhun took the most ambitious scope - a multi-feature immigration companion - and pushed it through all six pipeline stages, including the production feedback loop.
20 work orders, 6 phases, zero manual tickets
- Scope: document vault with translation, payslip analysis, Open Banking, deadline notifications, status checklists, and a grounded AI assistant.
- Traceability by construction: deliverables reference acceptance-criteria IDs directly (e.g.
AC-AI-003.2) - every file walks back to a requirement. - The loop closed: a real user submitted feedback in the app → it arrived in Software Factory's inbox → one click converted it into scoped work order WO-20 → it appeared in the same MCP queue Claude Code had been draining all along.
"The gap in AI-assisted development isn't code generation. It's everything around it. This is the part that makes it a system rather than a toolchain."
Three tools, three layers - not three competitors
| Dimension | Claude Code | Replit (Agent) | Software Factory |
|---|---|---|---|
| What it is | Agentic coding tool in your terminal / repo | Browser IDE with app agent + hosting | Requirements, blueprint & delivery platform |
| Code generation | Strong - full-repo context, multi-file changes | Strong for greenfield prototypes | None - directs coding agents instead |
| Requirements & specs | None built in - quality depends on prompt | Conversational only | Core strength - docs, acceptance criteria, blueprints |
| Traceability | Git history only | Limited | Requirement → blueprint → WO → code links |
| Feedback loop | Manual | Manual | Built in: in-app feedback → inbox → work order |
| Best fit | Implementation engine for real codebases | Rapid disposable prototypes | Spec, governance & delivery backbone |
His recommendation: adopt the layered model - a spec platform as the backbone, Claude Code as the engine - pilot it on one real internal project, standardize human review gates, and wire the feedback loop into production from day one.
Quotation Generator: the full cycle for four dollars
Rohan measured the pipeline's economics on a small, local-first desktop app - and found both the standout feature of the whole review and its proportionality problem.
Define → design → plan → build, measured
Code-grounded planning
The planning agent read the real source and planned against it - it caught that express.json({ limit: '2mb' }) would break a base64 logo upload and recorded it as an explicit decision before any code was written. Planning that reacts to real code is the genuine differentiator.
Structure, handoff, decomposition
A traceable Business Problem → Requirements → Blueprints → Work Orders pipeline with decisions captured as ADRs; a clean planning/building split where the MCP work order is the contract; and a vague "quotation app" turned into dependency-ordered, coherent work orders.
Great differentiator, steep on-ramp
- Unclear next action. At most screens it wasn't obvious what to do next - the first hour was trial and error.
- Concept overload. Requirements vs Feature Requirements, Blueprints, Containers, Components, Work Orders, Artifacts - a steep upfront vocabulary curve.
- Overhead vs payoff on small apps. Setting up the pipeline for one feature took effort comparable to just building it. Value clearly grows with codebase size and lifetime.
- Boilerplate leakage. Generated docs shipped with template placeholder text mixed into real content.
- Prerequisites before value. Code-grounded planning needs the repo pushed and indexed first - a barrier for quick experiments.
- Plans, doesn't build. It always hands off to a coding agent - worth setting that expectation.
Rohan's ratings (1-5)
Foremost: stress-testing the integration story
Shruti ran the most forensic review - 20 confirmed strengths, a headline bug, and the clearest picture of what the MCP round-trip actually does.
The intent → spec → backlog → code loop is real
main, all pushed, nothing uncommitted- Headline integration win: work-order statuses updated automatically in Software Factory as Claude Code progressed (build →
in_review→ completed) - and the agent read real work-order content over MCP, not just titles. - Verification before commit: every work order was linted and exercised via automated browser testing - validation errors, sort order, filter combinations all tested. The agent didn't just write code; it ran it.
- Provenance recovered: a UI revamp done outside the pipeline (directly in the Claude desktop app) was backfilled as WO-9/WO-10, linked to blueprints and commit SHAs. The backlog can absorb ad-hoc work and keep provenance intact.
- Blueprint composition model: Containers + shared Components + feature blueprints that reference each other via
@/#linking - the reason generated work orders referenced real component names likeTaskStoreandFilterControls.
One bug that matters, three gaps that add up
Placeholder text is real content
"Write document content here…" is persisted content, not a UI placeholder - it got prepended into agent-generated documents (observed on the Business Problem doc). It can ship into a real spec unnoticed, and clicking mid-text to edit corrupts the document.
Quick Start checklist tracks itself, not you
The checklist showed "4 of 6" with "Write a Feature Requirements Document" unchecked - while the generated FRD was on screen and the whole app was already built via MCP. A new user could think they're stuck when they're done. Plus: silent validation on project creation (empty names just reset).
Feedback module skips the developer
It's scoped to live end-user telemetry (endpoint + API key in a deployed backend). There's no lightweight path for a developer reviewing the build to log "I don't like this UI" → work order. For an undeployed frontend-only project, the loop can't be exercised at all.
Two un-consolidated token pools
~2.37M tokens (~$3.25) in Software Factory plus a separate, invisible Claude Code pool. No single view shows true end-to-end spend - and ~$3+ of orchestration for a task-manager MVP suggests steep scaling on larger projects.
"The loop is real, demoable, and traceable end-to-end. Rough edges are mostly polish and workflow-clarity issues, not fundamental gaps - with one exception that could corrupt real specs if unnoticed."
Best-in-class handoff, opaque costs
Open questions she left for 8090
- Is the placeholder bug intermittent, or tied specifically to docs derived from the pre-existing empty overview templates (net-new feature docs were clean)?
- Is there an intended native path for developer-side (non-telemetry) feedback → work order during a build, short of manually authoring work orders?
- Is there (or planned) a consolidated cost/token view spanning both Software Factory orchestration and the coding agent's execution, so teams can see true end-to-end spend?
Shruti's ratings (1-5)
The CTO review: same app, three harnesses, one video
Aemal built the identical product three times with three different setups and recorded a side-by-side comparison - then judged Software Factory against a harness he built himself a year ago.
AvaTask, built three times
The test project: a simple task-management system with a Kanban board. Same product, three fundamentally different build setups - so the differences you see are the harness, not the app.
Software Factory + Claude Code
Software Factory's MCP server connected to Claude Code running the Fable 5 model. Requirements, blueprints and work orders authored in Software Factory; implementation pulled through the MCP contract.
Bare Claude Code
Just Claude Code with Fable 5 - no MCP, no spec platform, no extra harness. The baseline: what does the same model do with nothing but a prompt and a repo?
Claude Cowork + Opus 4.8
Opus 4.8 in the Claude Cowork desktop app. The tool calling, caching, state management and agent harness are excellent - and the UX quality of the output was the best of the three.
Spoiler from the demo: the harness around the model matters as much as the model - and each setup showed it differently.
Side by side: Software Factory vs. Claude Code
Aemal demos all three AvaTask builds live - walking through what Software Factory generated, what bare Claude Code produced, and how the Cowork build compares, with his insights along the way.
I've been here before: VibeBox, one year ago
Almost exactly a year ago Aemal built VibeBox - a three-agent development environment combining Claude Code, Cursor, and Task Master AI working together on complex software development tasks.
- Three agents in harmony: Claude Code for generation and analysis, Cursor for intelligent editing, Task Master AI managing and coordinating tasks across the workflow - both coding agents producing code simultaneously.
- Dockerized for safety: built specifically to contain Claude's YOLO mode (
--dangerously-skip-permissions), which is risky in unrestricted environments. - Same thesis as Software Factory: a task layer directing coding agents - Task Master played the role work orders play today.
VibeBox - Claude Code, Task Master AI and Gemini in a dockerized loop
The mini hackathon: an n8n Python SDK in 4 hours 9 Sept 2025
To put VibeBox to the test, we ran a small hackathon: build a working n8n Python SDK, vibe-coded end to end.
Plus networking and a lot of fun. The lesson stuck: a contained, long-running agent harness with a task layer can ship a real deliverable in an afternoon.
VibeBox → AvaBox: an agent harness built for Avanai FDEs
VibeBox is being refactored into AvaBox - the same idea, purpose-built for FDEs working at Avanai, so we can build client work much faster. Task management is just the start; AvaBox adds:
Vercel integration
Deploy previews wired into the loop from the first commit.
Corporate identity
Avanai design system applied by default - no more generic scaffolds.
Linters & security scanners
Static analysis and security checks as first-class harness citizens.
Code reviewers
Automated review agents pass over everything before a human sees it.
Self-healing Docker runs
Containers for long-running, self-reviewing and self-healing processes.
Playwright plugin
The produced web app is checked in a real browser, automatically.
Test coverage
Coverage tracked and enforced as part of the definition of done.
MCP → n8n Microflows
An MCP interface to the client's n8n instance to create Microflows - an Avanai invention, like microservices but for n8n.
Task management - the layer everything above stands on
The original VibeBox core: a task layer coordinating the agents. Every capability above plugs into it - it is the foundation of AvaBox, not just another feature.
What Software Factory gets right
- A great UI for spec-driven development. Software Factory is the best-in-class front door for defining software before building it.
- Granular, UI-level access to the spec. It lets you write and refine Markdown files at a fine-grained level - files that will help any coding agent that connects to it, not just one vendor's.
- The MCP interface is genuinely nice. Blueprints, work orders and more can be created from the coding agent side - the contract flows both ways.
"Probably a good tool for building clones of something fast. But for maintaining and doing small changes, direct bare-bones Claude Code with a few skills and commands is the better option."
The rough edges
Small UI bugs
State management drifting out of sync, no GitHub integration possible on an empty repository, and similar paper cuts across the flow.
The "Loop" harness needs UX work
It generates all Work Orders inside a tiny chat window - the core planning experience deserves far more screen than it gets today.
Token consumption & cost
It measurably increases token spend, and the cost attached is concerning specifically for small changes to an existing application.
MCP status round-trip failed here
The MCP integration couldn't update work-order statuses in Software Factory - Claude had to be explicitly asked to update them each time.
Permission fatigue
"I had to press Yes a lot of times." Claude asked for too many permissions across the run to feel autonomous.
The feedback feature is an overkill
Using an API to inject a UI element into the end user's application stretches a developer tool all the way into end-user feedback collection. This tool should stay a developer tool.
What I'd like to see next
- Deep coding-agent integration. Bring the agent inside Software Factory so it becomes a full build environment - think Replit, but spec-first.
- Self-hosting for large organisations. Enterprises will want this running inside their own walls.
- More git hosting integrations. GitHub-only is limiting - GitLab and others are table stakes for enterprise teams.
- Initial PRs generated by the Software Factory agent. Today the first scaffold had to be generated with Claude and then carried into Software Factory - the platform's own agent should handle that first mile.
- Stay a developer tool. Focus the product on the developer loop rather than stretching into end-user feedback collection.
"Running it inside a Docker container with Claude's --dangerously-skip-permissions flag might make it run for multiple hours in a loop and build an entire clone of a SaaS overnight. That's worth another mini hackathon - like the n8n Python SDK we built a year ago. I'd be happy to chat with the 8090 team about this idea. Please feel free to connect me."
Where all four reviews converge
The spec layer is real
All four reviews land on the same core strengths: planning grounded in real code - the only 5/5 rating Rohan gave; full traceability from requirement to blueprint to work order to commit; an MCP handoff where the coding agent reads real work-order content, not just titles (confirmed by both Midhun and Shruti); and granular, UI-level access to agent-ready Markdown specs (Aemal). The pipeline demonstrably carries real apps from intent to committed code.
Cost, onboarding, proportionality
Token spend is high and split across two un-consolidated pools (Shruti, Aemal, Rohan); onboarding is steep with unclear next actions (Rohan); the overhead outweighs the payoff for small apps and small changes (Rohan, Aemal); and placeholder/state bugs undermine trust in generated specs (Shruti, Rohan, Aemal).
| Use case | Our verdict |
|---|---|
| Greenfield builds & clones | Strong fit - spec-first pipeline shines, agent stays on rails, traceability comes free. |
| Large, long-lived codebases | Promising - value grows with size; needs self-hosting and broader git support for enterprise. |
| Maintenance & small changes | Poor fit today - token cost and ceremony outweigh benefit; bare Claude Code with skills wins. |
| End-user feedback collection | Split opinion - a sophisticated closed loop (Midhun) vs. overreach for a dev tool (Aemal); either way, the developer-side loop is the gap (Shruti). |
Screenshot walkthrough - ←/→ to browse · click thumbnails · filter by tag
Spec-driven development is coming.
The harness decides who wins.
Software Factory proves the spec layer works. Our job as FDEs is to pair it with the right execution harness - and where the fit isn't right, to build our own. That's AvaBox.
8090 team - up for the overnight-SaaS-clone hackathon? Aemal would love to chat.