What is a software factory? Inside Jotform's AI version
Jotform runs 5 or 6 AI software factories; its bug-fix factory fixed 100 to 200 bugs in about a month. Aytekin Tank explains the line and his 3 rules.
Published 22 min read
Founder, GrowthMarketing.ai
15+ years of experience
Emre Elbeyoglu is a B2B SaaS growth expert and Founder of GrowthMarketing.ai. With 15+ years of SEO and GEO experience, he studies search and AI ranking systems to support growth work for brands including Rakuten and Investing.com. He has also bootstrapped SaaS products including Popupsmart and LiveChatAI.
- Computer Technology & Information Systems, Bilkent University
- Co-founder & Growth Lead, Popupsmart (since 2019)
- Co-founder, LiveChatAI (since 2023)

Share article
Explore with AI
A software factory is a chain of AI agents that takes defined work in and ships tested changes out, while people decide what gets built. Jotform runs five or six of them. Founder Aytekin Tank says its bug-fix factory fixed 100 to 200 bugs in about a month, though people still open the tickets that feed it.
Watch the full 59-minute interview above (English dub), or the 7-minute part on Jotform's AI factories under the next heading.
Video summary and key insights
Aytekin Tank founded Jotform and has built it for 20 years. I'm Emre Elbeyoglu, founder and CEO of SEOmator, and in this part of my interview with him, Aytekin Tank explains what Jotform calls an AI factory and walks through its bug-fix factory station by station, from the bug report to the reply the user gets. Then I ask whether autonomous agents can get out of hand, and Aytekin Tank answers with the three rules he runs every factory by. The glass factory is the idea I'd take from this part: a line that runs on its own while people can see and review every decision it makes.
- Jotform has built five or six AI factories. Aytekin Tank says each one runs a repeatable job from start to finish, with agents handing work to each other like machines on a line.
- The bug-fix factory fixed 100 to 200 bugs in about a month. It reproduces the bug, decides the fix, designs it, builds it, tests it, ships it and tells the user.
We set up bug-fix factories, and right away 100, 200 bugs were fixed in the last month or so.
- The last station writes to the user. Sometimes within two hours of the report, the AI tells the person who found the bug that it is fixed and asks them to check.
- Rule one is full autonomy. A line that stops for human approval at each step never reaches its full efficiency, and getting a factory to run alone takes three months or more.
- Rule two is that everything gets reviewed. People don't approve each step before it runs; they review everything the factory produces, the way Jotform's support team reviews every answer its AI gives users.
- Rule three is full measurement. Aytekin Tank starts the day with a report of how many bugs came in, how many were fixed, and where the rest got stuck.
A dark factory is a lights-out factory. And then there's another concept called a glass factory. Okay, inside it's dark, but from the outside you see absolutely everything. You track everything. And that's how we do it.
I had heard "AI factory" used at a tech event and asked Aytekin Tank to explain it because, as he put it in the interview, the topic was trending and a practitioner's experience was worth more than the trend. This post is that explanation, set against what the pages that rank for "software factory" say. Most of them sell a factory product. None of them follows a customer's bug all the way to a reply to that customer, which is what Aytekin Tank describes.
The rest of the interview is collected in the Aytekin Tank interview hub.

What is a software factory?
A software factory is a repeatable, automated flow in which AI agents plan, build, test and review software: a ticket or spec goes in, a tested change comes out, and people decide what gets built. The readable pages in the current top results agree on the core of that definition.
Castro AI's guide puts it this way: "An AI software factory is a way of building software where AI agents write, test and review code while engineers set the spec and check the results" (its definition). The idea is older than coding agents. Michael Cusumano of MIT described software factories in a 1991 Sloan School working paper as, in GlassFlow's summary, "a way to run many projects with one well-organised setup." The new part is who staffs the stations. If you're new to the term, our guide to AI agents covers the building block.
None of those definitions comes from a company running one on real customer work. Aytekin Tank's description is the plainest I've heard:
There's a factory. In this factory there are machines, automations. And when an action finishes in one automation, it moves to the next automation.
Put the usual definition next to Jotform's version and the biggest gap shows up at the end of the line:
| Part of the factory | In most definitions | At Jotform, in Aytekin Tank's account |
|---|---|---|
| What goes in | An issue, ticket or spec | A bug report that a person turns into a ticket |
| The stations | Plan, build, test, review | Reproduce, solve, design, build, QA by concern |
| What comes out | A pull request a person merges | A fix in production and a reply to the user |
| What people do | Decide what to build, approve releases | Open tickets, review every output, read the daily numbers |
How does Jotform's bug-fix factory work?
Jotform's bug-fix factory passes each reported bug through a chain of single-purpose agents, from reproducing the bug to shipping the fix and telling the user, with no person writing the fix. Aytekin Tank says it fixed 100 to 200 bugs in about a month.
The line starts with a person. When a user reports a problem, Jotform's support AI doesn't open the ticket itself; when it decides one is needed, it hands the case to people, and they open it. From there, in the parts of the product where the factory runs, the agents take over. Aytekin Tank was careful to say it isn't everywhere yet (at 01:29), and that he expects it to be in a year.
These are the stations in the order Aytekin Tank named them:
- Ticket. A person opens it after the support AI flags the problem.
- Reproducing agent. It recreates the bug. If it can't, it goes back to the user, says the problem didn't occur, and keeps talking to them until it has what it needs.
- Solution agent. It decides how the problem should be fixed.
- Design agent. It decides how the fix should look and behave.
- Implementation agent. It builds the fix.
- QA agents. Several of them, each checking one concern: does the fix open a security hole, does it break the user experience?
- Production. The fix goes live in the product.
- Reply. The AI writes to the user who reported the bug.

The last station is the one no ranking page describes:
Finally, it gets pushed to production. The fix actually goes live in the product. And sometimes within two hours, the user who reported the bug gets a reply. The AI writes it: we fixed this, could you please check as well? So from start to finish, this is a factory run completely by AI automation.
The closest thing in the results is GlassFlow's account of its own factory: "When an outside user reported a problem on GitHub, the factory logged it, fixed it, reviewed the fix and shipped it, all within 23 minutes." That's faster, but it happened in GlassFlow's own repository, and the story stops at shipping. Jotform's line goes one step further and writes back to whoever reported the bug, which is the part a customer notices.

What are the three rules of an AI factory?
Aytekin Tank runs every Jotform AI factory by three rules: it must be fully autonomous, everything it does must be reviewed, and it must be measured in full. He drew them from the five or six factories Jotform had built by the time of the interview.
We've built like five or six AI factories so far. And based on what I've seen and learned from them, there are three principles. The first principle is it has to be completely autonomous. Because whenever you leave everything up to human approval, you just can't get that full efficiency.
Side by side, with what each rule means at Jotform and why Aytekin Tank holds it:
| Rule | What it means at Jotform | Why |
|---|---|---|
| 1. Fully autonomous | No human approval gate inside the line | Approval at each step caps efficiency; reaching full autonomy takes three months or more |
| 2. Everything reviewed | People review every output without holding up the line, as the support team reviews every AI answer | Bad decisions get feedback, and the factory improves from it |
| 3. Full measurement | A daily report: bugs reported, fixed, stuck, and where they got stuck | Charts show where the line works and where it breaks |
Rules one and two, autonomy and review, look like they clash, and most vendors settle it the other way. ACE Dev's documentation says its AI "is not trusted to ship, merge, deploy, or spend without an explicit human 'yes'" (ACE Dev's docs). Stripe wrote in February 2026 that its coding agents produce over a thousand merged pull requests a week, and each one is human-reviewed before it merges. Aytekin Tank moves the person out of the line and onto the output, which is what lets the line run unattended.
Rule three is the one I'd copy first. It's how you find out whether the other two work:
For example, in the bug-fix factory, every morning when I come in: how many bugs were reported yesterday? How many were actually fixed? How many got stuck? Where did they get stuck?

What is the difference between a dark factory and a glass factory?
A dark factory is one where no human writes or reviews the code, like a lights-out plant with nobody inside. A glass factory runs on its own too, but every decision it makes stays visible and gets reviewed from outside. Aytekin Tank says Jotform runs glass factories, and none of the six top-ranking "software factory" pages we could read names either term.
The dark version is real in software. Simon Willison wrote that Dan Shapiro called it "the Dark Factory level of AI adoption, where no human even looks at the code the coding agents are producing" (Simon Willison's write-up). StrongDM's AI team runs that way. Its software factory principles, published on February 6, 2026, say code "must not be written by humans" and "must not be reviewed by humans."
Aytekin Tank described the alternative:
Meaning everything the AI does is tracked. For example, what it does regarding UX, the decisions it makes, the things it builds: a designer always reviews them. If it's bad, they give feedback and then it gets improved.
Count the human-approval line most vendors sell, and there are three ways to run a software factory:
| Aspect | Dark factory | Glass factory | Human-approval line |
|---|---|---|---|
| Who writes the code | Agents | Agents | Agents |
| Human review | None of the code, by rule (StrongDM) | Every output, without stopping the line (Jotform) | Every change, before it merges (Stripe, ACE Dev) |
| Where people spend time | Specs and test scenarios | Reviewing decisions, improving the factory | Approving each pull request |
| Main risk | Errors no human reads | Bad output reaches users before review | Reviewers become the bottleneck |

My take: for anything a customer touches, glass is the safer default. A dark factory is a bet that your tests catch everything, and StrongDM spent its effort there, building scenario suites and clones of the services its software depends on. A glass factory accepts that some bad output will reach users before review and limits the damage by watching every decision. Jotform's support team already reviews every answer its support AI gives, as Aytekin Tank described when he showed how Jotform built its AI support agent, so the model wasn't new to the company.
The same choice comes up at SEOmator, where we're building an AI SEO Manager for B2B SaaS. Its agents do the SEO work itself: they track Google keywords and the prompts people ask AI assistants, find the revenue pages that need fixing and draft the fixes. Each fix waits for a person's approval before it goes live, which puts SEOmator on the human-approval line in the table above.
Is an autonomous AI factory safe?
Aytekin Tank's answer is that a factory of narrow automation agents isn't the same thing as an open-ended agent told to "figure it out", and that his three rules are what keep it contained. I raised it by playing devil's advocate.
Emre Elbeyoglu: These AI factories, everything moving fast is great. Did you read about that incident in detail, where agents stepped outside their sandbox to take action? Does something like that feel scary at all?
Aytekin Tank: The agents we build aren't really that type of agent. What we call an automation agent… The agents that broke out were actually totally unconstrained. They'd basically been told: figure it out somehow. And they solved it by hacking the system and breaking out. Ours don't do anything like that.

Both of them were describing a report they had read, and we haven't verified the incident ourselves. Aytekin Tank's distinction holds either way. In his description, each Jotform agent does one step on a defined input instead of chasing an open goal. He went further than I would, though: he said that with the three rules in place, "that kind of thing simply can't happen" (at 06:27). Review and measurement catch bad output after it happens. Permissions and sandboxing decide what an agent can reach in the first place, and a factory needs those too.
What else can a factory build besides bug fixes?
Jotform also runs a factory that makes form templates, which none of the ranking pages would lead you to expect: all six readable top results describe factories that produce software.
Aytekin Tank described it in the next part of the interview. Jotform watches what kinds of forms people create, and a team used to build matching templates by hand, such as the consent form someone in Ireland signs before a vaccine. Google sent traffic to those templates, a source Evren Bayraktar also described in Jotform's growth story, and Aytekin Tank counts them among the reasons Jotform grew faster than its competitors during the pandemic. Evren Bayraktar has told me that traffic to those template pages falls month over month, and his team links the decline to AI Overviews (Jotform's SEO and AI search strategy). For about a year now, that team hasn't made templates:
Instead of creating form templates themselves, this team is developing the factory that creates those form templates. They don't make the templates by hand anymore.
That part, and what it meant for the people on the team, is in Will AI replace software engineers?. A factory fits any output with a clear specification and a way to check it. A template either matches the form people need or it doesn't, and that is the same property that makes vertical AI agents work in narrow domains.
How long does it take to build a software factory?
At Jotform, a factory takes at least three months to reach the point where it runs on its own, according to Aytekin Tank. He was clear that the hundredfold gains come from the finished factory; AI tools alone gave Jotform's developers about 2x and then about 10x.
It has to run completely on its own; that has to be our goal. Getting there takes a lot of time, of course. At least three months or so. But that has to be the goal.
Later in the interview, Aytekin Tank qualified the 100x figure he had used for his teams: "Using AI doesn't mean productivity suddenly shoots up a hundredfold. Once you set up the factory, it hits 100x, and setting up that factory takes months." He also predicted that a year from now "nobody will be micromanaging anymore" (at 00:02), with the AI doing the work instead of being told each step.
If you want to try this, pick the first line the way Jotform's VP of Growth Evren Bayraktar picks what to automate, with his five-times rule for AI automation: work that repeats, with a clear done state. Bug fixes fit because a bug is either reproduced and gone or it isn't. Measure it from day one, as rule three says, so that three months in you can tell whether the factory works.
Frequently asked questions
What is a factory model of software development?
A factory model of software development treats building software like a production line: work arrives in a defined form, such as a ticket or a spec, and passes through fixed stations until a tested change ships. Michael Cusumano of MIT described software factories in 1991 as a way to run many projects with one well-organised setup. In 2026 the stations are AI agents rather than teams of people. At Jotform, Aytekin Tank describes each station as an automation: when one agent finishes its job, the ticket moves to the next one, the way a part moves between machines in a plant.
How hard is it to build your own software factory?
Building a software factory is a project of months, not an afternoon with a coding assistant. Aytekin Tank estimates that a factory takes at least three months to reach the point where it runs on its own, and Jotform had built five or six of them by the time of the interview. The hard parts are the ones around the agents: deciding the stations, reviewing what each one produces and measuring the whole line every day. Start with one narrow, repeatable kind of work that has a clear done state, such as bug fixes.
Is a software factory the same as AI coding tools like Claude Code?
No. A coding tool like Claude Code is an assistant one developer drives in a session, while a software factory chains several agents with fixed jobs and runs on queued work without someone typing each step. GlassFlow compared the two on its own work, with one developer: its factory shipped 21.8 changes a day in October 2026 against 4.3 from plain Claude Code sessions in September and October, and 19% of factory changes needed a fix within seven days against 46%. That is one vendor's measurement of its own product. Aytekin Tank's factories at Jotform go further and include stations for design, security and user replies.
What does a bug-fix factory do?
A bug-fix factory takes a reported bug and runs it through agents until the fix is live and the user has an answer. In Aytekin Tank's description of Jotform's line, one agent reproduces the bug and asks the user for details when it can't, the next decides how to solve it, a design agent decides how the fix should look, an implementation agent builds it, and several QA agents check security and user experience. The fix then goes to production, and the AI writes to the user who reported it, sometimes within two hours. Jotform's bug-fix factory fixed 100 to 200 bugs in about a month.
What is a dark software factory?
A dark software factory is one in which no human writes or reviews the code, named after lights-out manufacturing plants where robots work in the dark. Dan Shapiro used the term for the level of AI adoption where nobody even looks at the code coding agents produce, and StrongDM's AI team describes running that way: its rules say code must not be written by humans and must not be reviewed by humans. Aytekin Tank says Jotform does not run dark factories. Jotform's factories run on their own, but every decision they make is tracked and reviewed.
What is a glass factory in AI?
A glass factory is an AI factory that runs on its own inside while everything it does stays visible and reviewed from outside. Aytekin Tank used the term to describe how Jotform runs its AI factories: the agents work without waiting for approval at each step, but people track every output and decision. A designer reviews the user-experience decisions the agents make and gives feedback when they are bad, and that feedback goes back into the factory. Jotform's support team does the same for the answers its support AI gives users.
How long does it take to build an AI software factory?
At Jotform it takes at least three months for a factory to reach the point where it runs on its own, according to Aytekin Tank. He also warned that using AI doesn't by itself make a team a hundred times more productive: that comes once a factory is set up, and setting it up takes months. Jotform's form-template factory, for comparison, had been running for about a year at the time of the interview. Plan for a quarter of building, reviewing and measuring before you judge a factory's output.
Does a software factory replace developers?
Not at Jotform. Aytekin Tank says nobody was laid off as Jotform's teams moved to factories; the developers stopped doing the fixes themselves and started building and improving the factories that do them. He argues that a team that becomes far more productive is worth more, not less, and that people stay accountable for what ships in a way AI cannot be. The results that rank for this question agree that a factory speeds up defined work but does not decide what to build. That decision stays with people.
How do you keep an autonomous AI factory safe?
Give each agent one narrow job instead of an open-ended goal, review everything the factory produces, and measure the whole line every day. Those are the answers Aytekin Tank gave when asked about agents that escaped a sandbox. Aytekin Tank's point was that agents told to solve a problem however they can are a different thing from Jotform's automation agents, which each do one step. He said that with his three rules in place, an escape like that can't happen. Rules lower the risk; permissions and sandboxing still decide what an agent can reach.
Key takeaways
- A software factory is a chain of AI agents with fixed jobs: defined work goes in, a tested change comes out, and people decide what gets built.
- Jotform has built five or six AI factories, and its bug-fix factory fixed 100 to 200 bugs in about a month, according to Aytekin Tank.
- Jotform's bug-fix line ends with a reply to the user who reported the bug, sometimes within two hours.
- Aytekin Tank's three rules: fully autonomous, every output reviewed, everything measured.
- A glass factory runs unattended but stays visible; a dark factory, like StrongDM's, removes human review by rule.
- Factories aren't only for code: Jotform's template factory makes form templates.
- Expect three months or more before a factory runs on its own.
For more first-hand accounts like this one, join the GrowthMarketing.ai newsletter.
Methodology: this post is based on an interview I recorded with Aytekin Tank in Turkish in 2026. Quotes come from the English dub, checked against the Turkish original and lightly edited for clarity. Figures about Jotform, such as the number of factories, bugs fixed and time to build, are Aytekin Tank's own statements with their timestamps, not measurements by GrowthMarketing.ai. The "top results" are the Google results for "software factory" in the US on November 19, 2026, six of which we could read in full.