Building a Fully Autonomous Software Factory with AI Agents

software_factory · Tech · 2026 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.4 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Autonomous software development workflow

The project tested whether a Notion-style product could be built and iterated by AI agents alone, with humans shifting from writing code to planning, product judgment, feedback, and quality control.

Constraints:

the system intentionally avoided human-written code
AI agents could build features quickly but still struggled with UI testing and polish
thin specifications caused downstream bugs and missing product detail
product prioritization became harder because AI changed the expected cost and time of work
the source is an experiment transcript rather than a mature production deployment

Architecture

The software factory combines AI coding agents, a product planning loop, a GitHub backlog, application feedback capture, Slack review/actioning, automated tests, and UI issue screenshots. Humans define or refine product direction, while agents plan, create issues, write code, add tests, collect feedback, and attempt self-improvement. The Memo app is the running product used to test the factory.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  human-product-loop[Human product loop] --> owner-planning-chat[Owner planning chat]
  owner-planning-chat --> github-factory-backlog[GitHub factory backlog]
  github-factory-backlog --> ai-coding-agents[AI coding agents]
  ai-coding-agents --> memo-application[Memo application]
  memo-application --> feedback-tool[Feedback tool]
  feedback-tool --> feedback-database[Feedback database]
  feedback-database --> owner-automation[Owner automation]
  owner-automation --> slack-feedback-channel[Slack feedback channel]
  slack-feedback-channel --> human-product-loop
  ai-coding-agents --> automated-tests[Automated tests]
  automated-tests --> memo-application

Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component	Role	Interacts with
`Human product loop`	Humans decide product priorities, judge quality, and intervene on planning and polish.	`Owner planning chat`, `Slack feedback channel`
`Owner planning chat`	Planning mode where product ideas are discussed and converted into feature/backlog work.	`Human product loop`, `GitHub factory backlog`
`GitHub factory backlog`	Issues and feature tasks generated for agents to implement.	`Owner planning chat`, `AI coding agents`
`AI coding agents`	Claude/Codex-style agents that implement features, tests, fixes, and self-improvement tasks.	`GitHub factory backlog`, `Memo application`, `Automated tests`
`Memo application`	Notion-style note-taking product being built by the factory.	`AI coding agents`, `Feedback tool`, `Automated tests`
`Feedback tool`	In-product mechanism for users to submit feedback and screenshots.	`Memo application`, `Feedback database`
`Feedback database`	Stores submitted feedback for automation to assess.	`Feedback tool`, `Owner automation`
`Owner automation`	Collects feedback, assesses it, and highlights items for action.	`Feedback database`, `Slack feedback channel`
`Slack feedback channel`	Human review/actioning surface for feedback and automation output.	`Owner automation`, `Human product loop`
`Automated tests`	Tests and UI checks created by agents to validate features and discover bugs.	`AI coding agents`, `Memo application`

Data flow

Humans discuss a product goal with the Owner planning chat, which breaks the work into GitHub issues. AI agents implement the issues, add tests, and ship into the Memo app. Users submit UI feedback, the product stores it in a database, automation assesses it and highlights it in Slack, and humans can action the feedback back into the factory. Screenshots and bug reports give the agents context for repairs.

3 supporting quotes

“we are building a completely autonomous product on owner using only AI agents. No human code here. Everything written by uh yeah agents. Uh our product is me on notion style note takingaking app.”transcript, stated

“the feedback tool within the UI. This basically goes into the database and our owner automation is then uh collecting the feedback assessing it and highlighting it to us in Slack.”transcript, stated

“you can see in the in a factory backlog on GitHub uh what the product has actually come up with in terms of the the features”transcript, stated

Why this architecture

The architecture exists to test whether software development can become an agent-managed factory. The transcript argues that agents compress implementation from weeks to days, which shifts human work toward deciding what is valuable, supplying sufficient specs, reviewing quality, and managing feedback loops.

3 supporting quotes

“once you can kind of orchestrate agents in a meaningful way like you've been doing um it's insane how fast you can go.”transcript, stated

“we still need humans in the loop to to kind of polish off the UI like you showed me and did the last mile of things”transcript, stated

“it's insane how fast you can go. So the conversation really does move to um we still need humans in the loop to to kind of polish off the UI like you showed me and did the last mile of things and just to make sure we are focusing on the right things and to maintain the product”transcript, stated

Models used: Claude · Codex

Scale

The transcript is from day eight of the software-factory experiment.
“Hello everyone. Welcome back to day eight of building a software factory. Uh we are building a completely autonomous product on owner using only AI agents.”transcript, stated
The initial product reportedly took two days instead of a three-to-four-week estimate.
“for the factory uh we we got an estimate oh this will take three four weeks to build and you know effectively took two days for for it to crunch out the um yeah the initial product. I guess that's also like the way LM are trained and you know all the data that's out there on on”transcript, stated
The transcript contrasts estimates from eight days to months for similar AI-enabled work.
“something similar would you would get wide ranging estimates from eight days which is what you've done to probably a few months and you're both correct it just depends on you know who's doing it and and um you know exactly where you are on that journey of of of figuring”transcript, stated

Alternatives considered (roads not taken)

Human-written code

Rejected because: The experiment intentionally uses only AI agents to write the product code.

“No human code here. Everything written by uh yeah agents. Uh our product is me on notion style note takingaking app. And for yeah the last one and a half weeks we've been walking through how we set the factory up um how we built the”transcript, stated

Heavy upfront planning for every feature

Rejected because: The team debates a balance between planning and iteration because agent speed lowers the cost of trying features but thin specs cause UI bugs.

“a fine line or like a valid trade-off before between planning too much and just you know like I did for example with databases spending 10 15 minutes”transcript, stated

Treat the factory as fully autonomous without human quality gates

Rejected because: The transcript says humans still need to polish UI, focus on valuable work, and maintain product quality.

“still need humans in the loop to to kind of polish off the UI like you showed me and did the last mile of things and just to make sure we are focusing on the right things and to maintain the product surface too. But ensuring we only add really high value things you know as a”transcript, stated

Patterns

`multi-agent-orchestration` (orchestration)

The factory coordinates coding agents to plan, implement, test, fix, and improve the product rather than using one single manual coding loop.

“once you can kind of orchestrate agents in a meaningful way like you've been doing um it's insane how fast you can go.”transcript, stated

`human-in-the-loop-gate` (workflow)

Humans stay responsible for product judgment, UI polish, and selecting high-value work even when agents generate code.

“ensuring we only add really high value things you know as a level of polish that you're really proud of becomes becomes the job now.”transcript, stated

`eval-driven-development` (evaluation)

The factory adds tests, catches some bugs, and uses feedback/screenshots to improve the product and the automation.

“it discovered a few bugs in the testing and in the end to end tests that it then added.”transcript, stated

`data-quality-loop` (data)

User feedback is captured in the product, stored, assessed by automation, and surfaced in Slack for further action.

“the feedback tool within the UI. This basically goes into the database and our owner automation is then uh collecting the feedback assessing it”transcript, stated

Tradeoffs

Build with agents only

Chose AI agents writing all product code over humans coding the app directly.

Rationale: The experiment's goal was to test a fully autonomous software factory and learn where humans still need to steer.

“we are building a completely autonomous product on owner using only AI agents.”transcript, stated

Move faster with lighter feature specs

Chose 10-15 minutes of planning for the database feature over deep upfront planning.

Rationale: The speed produced a working feature but also UI bugs and follow-up test work.

“spending 10 15 minutes on kind of thinking about oh how could this be discussing with the owner chat”transcript, stated

Keep humans in the loop for product quality

Chose human product judgment and UI polish over fully automatic shipping based only on generated tests.

Rationale: Agent speed increases throughput, but product value and long-term ownership still require human judgment.

“the most expensive bit of building now I think is that that long-term ownership.”transcript, stated

Gotchas (what bit them)

UI testing quality lagged behind feature implementation.

Root cause: The database feature was generated from a thin specification and the automated UI checks missed layout bugs.

Resolution: Use screenshots and feedback to improve the tests and automation before trusting the factory's UI output.

“this is I think where coming back to what surprised me a little bit is how poor it did on the UI testing.”transcript, stated

Thin initial specs produce downstream repair work.

Root cause: The database feature was prompted from about five lines and not enough product detail.

Resolution: Spend more time on planning when the feature is beyond a typo-level change.

“the baseline prompt that I used. Uh, if you look into the the owner chat that I used to plan this out, it was literally, you know, five lines.”transcript, stated

AI-compressed timelines break old estimation instincts.

Root cause: The cost and time assumptions product managers and engineers built careers around no longer match AI-enabled development.

Resolution: Relearn prioritization around ownership cost, quality, and value rather than only engineering time.

“our sort of cognitive way of of of measuring things that we built up over entire careers just are not correct anymore.”transcript, stated

Evaluation

The experiment evaluates progress through working product features, generated tests, discovered bugs, screenshots, user feedback, and product-manager review rather than a formal benchmark.

Metrics: day-eight progress · two-day initial product build versus three-to-four-week estimate · database view feature added · UI bug captured with screenshot

“it added automatically a screenshot. So this is quite nice because owner and the automation itself you can make use of the screenshot analyze what's going on”transcript, stated

“the initial product and how we went from building the base into steering the product into better taste better design and new features.”transcript, stated

Outcomes

the factory built a working Notion-style editor
the system added database views, though with UI bugs
feedback capture and Slack actioning were added to close the product loop
the transcript identifies planning, UI testing, and product judgment as the next bottlenecks

This is an eight-day experiment, not a mature production system; the strongest numbers are elapsed time and comparison to prior estimates.

“we see the database works. However uh and this is I think where coming back to what surprised me a little bit is how poor it did on the UI testing.”transcript, stated

“we added now the feedback tool within the UI.”transcript, stated